Merge ~epics-core/epics-base/+git/rtems5libcom:hj/rtems5libcom into ~epics-core/epics-base/+git/epics-base:libcom/master

[Heinz Junkes]

[mdavidsaver (mdavidsaver)]

After a first pass reading through the diff I see two areas which need attention.

1) Parts of my RTEMS testing branch are still included. Not enough to actually work though. I'm referring to the files ne2kpci.*, epicsMakeMemFs.pl, and epicsMemFs.*. I think these could be removed with minimal effort.

2) There is still imo. too much duplication. The files I'd specifically like to see de-duplicated are: rtems_init.c, setBootConfigFromNVRAM.c, and osdThread.*.

review: Needs Fixing

[Heinz Junkes (junkes)]

> On 5. Apr 2018, at 20:20, mdavidsaver <email address hidden> wrote:
>
> Review: Needs Fixing
>
> After a first pass reading through the diff I see two areas which need attention.
>
> 1) Parts of my RTEMS testing branch are still included. Not enough to actually work though. I'm referring to the files ne2kpci.*, epicsMakeMemFs.pl, and epicsMemFs.*. I think these could be removed with minimal effort.

Ok, thought this is a good idea to include this in rtemss5 … and only there. I had not touch the existing stuff.

>
> 2) There is still imo. too much duplication. The files I'd specifically like to see de-duplicated are: rtems_init.c, setBootConfigFromNVRAM.c, and osdThread.*.

The files are in the respective subfolders posix or kernel to be sure that the old stuff is untouched.
My first approach with ifdef's was not very nice.

[mdavidsaver (mdavidsaver)]

I did a diff of the RTEMS-kernel/ vs. RTEMS-posix/ vs. posix/ implementations. Some notes below:

> diff -uwrN RTEMS/kernel RTEMS/posix |less

= RTEMS/*/rtems_config.c

These one might as well be different files.

= RTEMS/*/rtems_init.c

The differences here are largely due to my testing changes having been applied to the posix/ version and kernel/ version. Backing these out from the posix/ version, most of the remaining changes have to do with NFS and TFTP file systems. I think this could be further reduced. eg. the 4.10 version of nfsMount() could use mount_and_make_target_path().

= RTEMS/*/rtems_netconfig.c

The diff here is smaller than I expected. Just the removal of loopback_config and not setting the bsdnet thread priority.

= RTEMS/*/setBootConfigFromNVRAM.c

I think all diff here is my doing, and should be applied to both or neither.

> diff -uwr src/osi/os/RTEMS-posix src/osi/os/posix | less

Most of this diff seems to be related to changes to the checkStatus* macro definitions and usage. I didn't look at this in detail.

There is some special handling of the main() thread which seems to be duplicated in init_threadInfo() and rtemsMainInit().

The remainder looks like differences to how thread priorities are handled.

= src/osi/os/RTEMS*/osdInterrupt.c

A verbatim copy.

= src/osi/os/RTEMS-*/osdPoolStatus.c

Another diff which was smaller than I was expecting.

[mdavidsaver (mdavidsaver)]

This work has moved to https://github.com/epics-base/epics-base/pull/23

review: Disapprove

Unmerged commits

bfe868e... by Heinz Junkes on 2018-03-28

Add support for Rtems 5

Rtems recommends the posix api for new developments to enable the use of
SMP in the future. To distinguish if posix is used the new GNUmake
variable $(OS_API) is evaluated in the makefile.

diff --git a/RTEMS/Makefile b/RTEMS/Makefile
index b0f3b6f..2fb2c36 100644
--- a/RTEMS/Makefile
+++ b/RTEMS/Makefile
@@ -6,12 +6,33 @@
 # EPICS BASE is distributed subject to a Software License Agreement found
 # in file LICENSE that is included with this distribution.
 #*************************************************************************
-
-TOP = ..
+TOP=../../..
 include $(TOP)/configure/CONFIG
-include $(TOP)/configure/CONFIG_LIBCOM_VERSION
 
-INC += epicsRtemsInitHooks.h
+SRC_IMPL_DIR = $(if $(OS_API),$(OS_API),) kernel
+
+SRC_DIRS += ../$(SRC_IMPL_DIR)
+
+ifeq ($(OS_API),posix)
+PERL_SCRIPTS += epicsMakeMemFs.pl
+endif
+
+INC += $(SRC_IMPL_DIR)/epicsRtemsInitHooks.h
+
+ifeq ($(OS_API),posix)
+INC += $(OS_API)/epicsMemFs.h
+endif
+
+ifeq ($(USE_RTEMS_GDBSTUB_$(T_A)),YES)
+rtems_init_CPPFLAGS += -DUSE_GDBSTUB
+endif
+
+ifeq ($(T_A),RTEMS-pc386)
+setBootConfigFromNVRAM_CPPFLAGS += -DUSE_MULTIBOOT
+endif
+ifeq ($(RTEMS_QEMU_FIXUPS),YES)
+rtems_init_CPPFLAGS += -DQEMU_FIXUPS
+endif
 
 rtemsCom_SRCS += rtems_init.c
 rtemsCom_SRCS += rtems_config.c
@@ -20,10 +41,14 @@ rtemsCom_SRCS += rtems_util.c
 rtemsCom_SRCS += setBootConfigFromNVRAM.c
 rtemsCom_SRCS += epicsRtemsInitHookPre.c
 rtemsCom_SRCS += epicsRtemsInitHookPost.c
+ifeq ($(OS_API),posix)
+rtemsCom_SRCS += epicsMemFs.c
+endif
 
-LIBRARY_RTEMS = rtemsCom
+ifeq ($(T_A),RTEMS-pc386)
+rtemsCom_SRCS += ne2kpci.c
+endif
 
-# shared library ABI version.
-SHRLIB_VERSION = $(EPICS_LIBCOM_MAJOR_VERSION).$(EPICS_LIBCOM_MINOR_VERSION).$(EPICS_LIBCOM_MAINTENANCE_VERSION)
+LIBRARY_RTEMS = rtemsCom
 
 include $(TOP)/configure/RULES
diff --git a/RTEMS/epicsRtemsInitHookPost.c b/RTEMS/kernel/epicsRtemsInitHookPost.c
index f589eb9..f589eb9 100644
--- a/RTEMS/epicsRtemsInitHookPost.c
+++ b/RTEMS/kernel/epicsRtemsInitHookPost.c
diff --git a/RTEMS/epicsRtemsInitHooks.h b/RTEMS/kernel/epicsRtemsInitHooks.h
index b7f09c1..b7f09c1 100644
--- a/RTEMS/epicsRtemsInitHooks.h
+++ b/RTEMS/kernel/epicsRtemsInitHooks.h
diff --git a/RTEMS/rtems_config.c b/RTEMS/kernel/rtems_config.c
index 147c08b..6612aad 100644
--- a/RTEMS/rtems_config.c
+++ b/RTEMS/kernel/rtems_config.c
@@ -1,17 +1,17 @@
 /*************************************************************************\
 * Copyright (c) 2002 The University of Saskatchewan
-* EPICS BASE Versions 3.13.7
-* and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  * RTEMS configuration for EPICS
  *      Author: W. Eric Norum
- *              [e-mail]
- *              [phone]
  */
 
 #include <rtems.h>
+#include <epicsVersion.h>
+#define RTEMS_VERSION_INT \
+     VERSION_INT(__RTEMS_MAJOR__, __RTEMS_MINOR__, __RTEMS_REVISION__, 0)
 
 /*
  ***********************************************************************
@@ -20,7 +20,7 @@
  */
 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE
 
-#if __RTEMS_MAJOR__>4 || (__RTEMS_MAJOR__==4 && __RTEMS_MINOR__>9) || (__RTEMS_MAJOR__==4 && __RTEMS_MINOR__==9 && __RTEMS_REVISION__==99)
+#if RTEMS_VERSION_INT >= VERSION_INT(4, 9, 99, 0)
 #  define CONFIGURE_UNIFIED_WORK_AREAS
 #else
 #  define CONFIGURE_EXECUTIVE_RAM_SIZE (2000*1024)
@@ -54,6 +54,7 @@ rtems_task Init (rtems_task_argument argument);
 #define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
 #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
 
+#define CONFIGURE_FILESYSTEM_TFTPFS
 #define CONFIGURE_FILESYSTEM_NFS
 #define CONFIGURE_FILESYSTEM_IMFS
 
diff --git a/RTEMS/rtems_init.c b/RTEMS/kernel/rtems_init.c
index 82871da..82871da 100644
--- a/RTEMS/rtems_init.c
+++ b/RTEMS/kernel/rtems_init.c
diff --git a/RTEMS/rtems_netconfig.c b/RTEMS/kernel/rtems_netconfig.c
index 832a664..83d50dd 100644
--- a/RTEMS/rtems_netconfig.c
+++ b/RTEMS/kernel/rtems_netconfig.c
@@ -16,58 +16,75 @@
 #include <bsp.h>
 #include <rtems/rtems_bsdnet.h>
 
+#include "rtems_netconfig.h"
+
 extern void rtems_bsdnet_loopattach();
 static struct rtems_bsdnet_ifconfig loopback_config = {
     "lo0",                          /* name */
-    (int (*)(struct rtems_bsdnet_ifconfig *, int))rtems_bsdnet_loopattach, /* attach function */
-    NULL,                           /* link to next interface */
+    (int (*)(struct rtems_bsdnet_ifconfig *, int))rtems_bsdnet_loopattach,
+    NULL,                           /* last interface */
     "127.0.0.1",                    /* IP address */
     "255.0.0.0",                    /* IP net mask */
 };
 
+#define stringOf(x) #x
+#define STRING(x) stringOf(x)
+
 /*
- * The following conditionals select the network interface card.
- *
- * On RTEMS-pc386 targets all network drivers which support run-time
- * probing are linked. 
- * On other targets the network interface specified by the board-support
- * package is used.
- * To use a different NIC for a particular application, copy this file to the
- * application directory and make the appropriate changes.
+ * The following configures up to 2 network interface card(s) using
+ * settings in either configure/os/CONFIG_SITE.Common.RTEMS or in a
+ * BSP-specific configure/os/CONFIG_SITE.Common.RTEMS-<bsp> file.
+ * If no settings are provided, it uses the BSP's defaults instead.
  */
-#if defined(__i386__)
-extern int rtems_fxp_attach (struct rtems_bsdnet_ifconfig *, int);
-static struct rtems_bsdnet_ifconfig fxp_driver_config = {
-    "fxp1",                             /* name */
-    rtems_fxp_attach,                   /* attach function */
-    &loopback_config,                   /* link to next interface */
-};
-extern int rtems_3c509_driver_attach (struct rtems_bsdnet_ifconfig *, int);
-static struct rtems_bsdnet_ifconfig e3c509_driver_config = {
-    "ep0",                              /* name */
-    rtems_3c509_driver_attach,          /* attach function */
-    &fxp_driver_config,                 /* link to next interface */
-};
-#define FIRST_DRIVER_CONFIG &e3c509_driver_config
-#else
 
-# if defined(__PPC)
-  /*
-   * FIXME: This really belongs in the BSP
-   */
-#  ifndef RTEMS_BSP_NETWORK_DRIVER_NAME
-#   define RTEMS_BSP_NETWORK_DRIVER_NAME "dc1"
-#  endif
-#  ifndef RTEMS_BSP_NETWORK_DRIVER_ATTACH
-#   define RTEMS_BSP_NETWORK_DRIVER_ATTACH rtems_dec21140_driver_attach
-    extern int rtems_dec21140_driver_attach();
-#  endif
-# endif
+#if defined(RTEMS_NETWORK_DRIVER_NAME_1)
+
+  #if defined(RTEMS_NETWORK_DRIVER_NAME_2)
+    static struct rtems_bsdnet_ifconfig netdriver_config_2 = {
+        STRING(RTEMS_NETWORK_DRIVER_NAME_2),
+    #if defined(RTEMS_NETWORK_DRIVER_ATTACH_2)
+        RTEMS_NETWORK_DRIVER_ATTACH_2,  /* specific attach function */
+    #else
+        RTEMS_BSP_NETWORK_DRIVER_ATTACH,    /* default attach function */
+    #endif
+        &loopback_config,                   /* loopback interface */
+    #if defined(RTEMS_NETWORK_IP4_ADDR_2)
+        STRING(RTEMS_NETWORK_IP4_ADDR_2),
+      #if defined(RTEMS_NETWORK_IP4_MASK_2)
+        STRING(RTEMS_NETWORK_IP4_MASK_2),
+      #endif
+    #endif
+    };
+  #endif /* RTEMS_NETWORK_DRIVER_NAME_2 */
+
+  static struct rtems_bsdnet_ifconfig netdriver_config = {
+      STRING(RTEMS_NETWORK_DRIVER_NAME_1),
+  #if defined(RTEMS_NETWORK_DRIVER_ATTACH_1)
+      RTEMS_NETWORK_DRIVER_ATTACH_1,  /* specific attach function */
+  #else
+      RTEMS_BSP_NETWORK_DRIVER_ATTACH,    /* default attach function */
+  #endif
+  #if defined(RTEMS_NETWORK_DRIVER_NAME_2)
+      &netdriver_config_2,                /* link to next interface */
+  #else
+      &loopback_config,                   /* loopback interface */
+  #endif
+  #if defined(RTEMS_NETWORK_IP4_ADDR_1)
+      STRING(RTEMS_NETWORK_IP4_ADDR_1),
+    #if defined(RTEMS_NETWORK_IP4_MASK_1)
+      STRING(RTEMS_NETWORK_IP4_MASK_1),
+    #endif
+  #endif
+  };
+  #define FIRST_DRIVER_CONFIG &netdriver_config
+
+#else /* RTEMS_NETWORK_DRIVER_NAME_1 */
 
+/* Use the BSP-provided standard macros */
 static struct rtems_bsdnet_ifconfig bsp_driver_config = {
     RTEMS_BSP_NETWORK_DRIVER_NAME,      /* name */
     RTEMS_BSP_NETWORK_DRIVER_ATTACH,    /* attach function */
-    &loopback_config,                   /* link to next interface */
+    &loopback_config,                   /* loopback interface */
 };
 #define FIRST_DRIVER_CONFIG &bsp_driver_config
 
@@ -77,9 +94,7 @@ static struct rtems_bsdnet_ifconfig bsp_driver_config = {
  * Allow configure/os/CONFIG_SITE.Common.RTEMS to provide domain name
  */
 #ifdef RTEMS_NETWORK_CONFIG_DNS_DOMAINNAME
-# define XSTR(x) STR(x)
-# define STR(x) #x
-# define MY_DOMAINNAME XSTR(RTEMS_NETWORK_CONFIG_DNS_DOMAINNAME)
+# define MY_DOMAINNAME STRING(RTEMS_NETWORK_CONFIG_DNS_DOMAINNAME)
 #else
 # define MY_DOMAINNAME NULL
 #endif
diff --git a/RTEMS/setBootConfigFromNVRAM.c b/RTEMS/kernel/setBootConfigFromNVRAM.c
index 6a162c6..6a162c6 100644
--- a/RTEMS/setBootConfigFromNVRAM.c
+++ b/RTEMS/kernel/setBootConfigFromNVRAM.c
diff --git a/RTEMS/ne2kpci.c b/RTEMS/ne2kpci.c
new file mode 100644
index 0000000..909d885
--- /dev/null
+++ b/RTEMS/ne2kpci.c
@@ -0,0 +1,58 @@
+/*************************************************************************\
+* Copyright (c) 2015 Brookhaven Science Associates, as Operator of
+*     Brookhaven National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/*
+ * Wrapper around the ISA ne2000 driver to support detection of the PCI variant.
+ * Can be used with the ne2k_pci device provided by QEMU.
+ *
+ * eg. "qemu-system-i386 ... -net nic,model=ne2k_pci"
+ */
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <bsp.h>
+#include <rtems/pci.h>
+#include <rtems/rtems_bsdnet.h>
+
+/* The plain ISA driver attach()
+ * which doesn't (can't?) do any test to see if
+ * the HW is really present
+ */
+extern int
+rtems_ne_driver_attach (struct rtems_bsdnet_ifconfig *config, int attach);
+
+int
+rtems_ne2kpci_driver_attach (struct rtems_bsdnet_ifconfig *config, int attach)
+{
+    uint8_t  irq;
+    uint32_t bar0;
+    int B, D, F, ret;
+    printk("Probing for NE2000 on PCI (aka. Realtek 8029)\n");
+
+    if(pci_find_device(PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8029, 0, &B, &D, &F))
+    {
+        printk("Not found\n");
+        return 0;
+    }
+
+    printk("Found %d:%d.%d\n", B, D, F);
+
+    ret = pci_read_config_dword(B, D, F, PCI_BASE_ADDRESS_0, &bar0);
+    ret|= pci_read_config_byte(B, D, F, PCI_INTERRUPT_LINE, &irq);
+
+    if(ret || (bar0&PCI_BASE_ADDRESS_SPACE)!=PCI_BASE_ADDRESS_SPACE_IO)
+    {
+        printk("Failed reading card config\n");
+        return 0;
+    }
+
+    config->irno = irq;
+    config->port = bar0&PCI_BASE_ADDRESS_IO_MASK;
+
+    printk("Using port=0x%x irq=%u\n", (unsigned)config->port, config->irno);
+
+    return rtems_ne_driver_attach(config, attach);
+}
diff --git a/RTEMS/posix/epicsMakeMemFs.pl b/RTEMS/posix/epicsMakeMemFs.pl
new file mode 100644
index 0000000..a97074e
--- /dev/null
+++ b/RTEMS/posix/epicsMakeMemFs.pl
@@ -0,0 +1,83 @@
+#!/usr/bin/env perl
+#
+
+use File::Basename;
+
+use strict;
+
+my $outfile = shift;
+my $varname = shift;
+
+open(my $DST, '>', $outfile) or die "Failed to open $outfile";
+
+print $DST <<EOF;
+#include <epicsMemFs.h>
+EOF
+
+my $N = 0;
+
+for my $fname (@ARGV) {
+  print "<- $fname\n";
+  my $realfname = $fname;
+
+  # strip leading "../" "./" or "/"
+  while ($fname =~ /^\.*\/(.*)$/) { $fname = $1; }
+
+  my $file = basename($fname);
+  my @dirs  = split('/', dirname($fname));
+
+  print $DST "/* begin $realfname */\nstatic const char * const file_${N}_dir[] = {";
+  for my $dpart (@dirs) {
+    print $DST "\"$dpart\", ";
+  }
+  print $DST "NULL};\nstatic const char file_${N}_data[] = {\n   ";
+
+  open(my $SRC, '<', $realfname) or die "Failed to open $realfname";
+  binmode($SRC);
+
+  my $buf;
+  my $total = 0;
+  while (my $num = read($SRC, $buf, 32)) {
+    if($total != 0) {
+      print $DST ",\n   ";
+    }
+    $total += $num;
+    my $out = join(",",map(ord,split(//,$buf)));
+    print $DST "$out";
+  }
+  
+  close($SRC);
+
+  print $DST <<EOF;
+
+};
+static const epicsMemFile file_${N} = {
+  file_${N}_dir,
+  \"$file\",
+  file_${N}_data,
+  $total
+};
+/* end $realfname */
+EOF
+  $N = $N + 1;
+}
+
+print $DST <<EOF;
+static const epicsMemFile* files[] = {
+EOF
+
+$N = $N - 1;
+
+for my $i (0..${N}) {
+  print $DST " &file_${i},";
+}
+
+print $DST <<EOF;
+ NULL
+};
+static
+const epicsMemFS ${varname}_image = {&files[0]};
+const epicsMemFS * $varname = &${varname}_image;
+EOF
+
+close($DST);
diff --git a/RTEMS/posix/epicsMemFs.c b/RTEMS/posix/epicsMemFs.c
new file mode 100644
index 0000000..4689d21
--- /dev/null
+++ b/RTEMS/posix/epicsMemFs.c
@@ -0,0 +1,110 @@
+/*************************************************************************\
+* Copyright (c) 2014 Brookhaven National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+
+#include "epicsMemFs.h"
+
+#ifndef PATH_MAX
+#  define PATH_MAX 100
+#endif
+
+int epicsMemFsLoad(const epicsMemFS *fs)
+{
+    char initdir[PATH_MAX];
+    const epicsMemFile * const *fileptr = fs->files;
+
+    if(getcwd(initdir, sizeof(initdir)-1)==NULL) {
+        perror("getcwd");
+        return errno;
+    }
+    initdir[sizeof(initdir)-1] = '\0';
+
+    for(;*fileptr; fileptr++) {
+        const epicsMemFile *curfile = *fileptr;
+        int fd;
+        ssize_t ret;
+        size_t sofar;
+        const char * const *dir = curfile->directory;
+        /* jump back to the root each time,
+         * slow but simple.
+         */
+        if(chdir(initdir)) {
+            perror("chdir");
+            return errno;
+        }
+
+        printf("-> /");
+
+        /* traverse directory tree, creating as necessary */
+        for(;*dir; dir++) {
+            int ret;
+            if(**dir=='.') continue; /* ignore '.' and '..' */
+            printf("%s/", *dir);
+            ret = chdir(*dir);
+            if(ret==-1 && errno==ENOENT) {
+                /* this directory doesn't exist */
+                if(mkdir(*dir,0744)==-1) {
+                    printf("\n");
+                    perror("mkdir");
+                    return errno;
+                }
+                if(chdir(*dir)==-1) {
+                    printf("\n");
+                    perror("chdir2");
+                    return errno;
+                }
+            } else if(ret==-1) {
+                printf("\n");
+                perror("chdir1");
+                return errno;
+            }
+        }
+
+        /* no file name creates an empty directory */
+        if(!curfile->name) {
+            printf("\n");
+            continue;
+        }
+        printf("%s", curfile->name);
+
+        /* create or overwrite */
+        fd = open(curfile->name, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+
+        if(fd==-1) {
+            printf("\n");
+            perror("open");
+            return errno;
+        }
+
+        sofar = 0;
+
+        while(sofar<curfile->size) {
+            ret = write(fd, curfile->data+sofar, curfile->size-sofar);
+            if(ret<=0) {
+                printf("\n");
+                perror("write");
+                return errno;
+            }
+            sofar += ret;
+        }
+
+        close(fd);
+        printf(" - ok\n");
+    }
+
+    if(chdir(initdir))
+        perror("chdir");
+
+    return 0;
+}
diff --git a/RTEMS/posix/epicsMemFs.h b/RTEMS/posix/epicsMemFs.h
new file mode 100644
index 0000000..c57f4d7
--- /dev/null
+++ b/RTEMS/posix/epicsMemFs.h
@@ -0,0 +1,24 @@
+/*************************************************************************\
+* Copyright (c) 2014 Brookhaven National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+#ifndef EPICSMEMFS_H
+#define EPICSMEMFS_H
+
+#include <stdlib.h>
+
+typedef struct {
+    const char * const *directory; /* NULL terminated list of directories */
+    const char *name; /* file name */
+    const char *data; /* file contents */
+    size_t size; /* size of file contents in bytes */
+} epicsMemFile;
+
+typedef struct {
+    const epicsMemFile * const *files;
+} epicsMemFS;
+
+int epicsMemFsLoad(const epicsMemFS *fs);
+
+#endif // EPICSMEMFS_H
diff --git a/RTEMS/posix/epicsRtemsInitHookPost.c b/RTEMS/posix/epicsRtemsInitHookPost.c
new file mode 100644
index 0000000..9d8ef65
--- /dev/null
+++ b/RTEMS/posix/epicsRtemsInitHookPost.c
@@ -0,0 +1,23 @@
+/*************************************************************************\
+* Copyright (c) 2006 The University of Chicago, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE Versions 3.13.7
+* and higher are distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Dummy version -- use if application does not provide its own version
+ */
+#include "epicsRtemsInitHooks.h"
+
+int
+epicsRtemsInitPostSetBootConfigFromNVRAM(struct rtems_bsdnet_config *config)
+{
+    return 0;
+}
+
+
+
+void bootpFallbackFromNVRAM(void) __attribute__((weak));
+void bootpFallbackFromNVRAM(void) {}
diff --git a/RTEMS/posix/epicsRtemsInitHooks.h b/RTEMS/posix/epicsRtemsInitHooks.h
new file mode 100644
index 0000000..4313f19
--- /dev/null
+++ b/RTEMS/posix/epicsRtemsInitHooks.h
@@ -0,0 +1,25 @@
+/*************************************************************************\
+* Copyright (c) 2006 The University of Chicago, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE Versions 3.13.7
+* and higher are distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Hooks into RTEMS startup code
+ */
+#include <bsp.h>
+#include <rtems/rtems_bsdnet.h>
+
+extern char *env_nfsServer;
+extern char *env_nfsPath;
+extern char *env_nfsMountPoint;
+
+/*
+ * Return 0 for success, non-zero for failure (will cause panic)
+ */
+int epicsRtemsInitPreSetBootConfigFromNVRAM(struct rtems_bsdnet_config *config);
+int epicsRtemsInitPostSetBootConfigFromNVRAM(struct rtems_bsdnet_config *config);
+/* Return 0 if local file system was setup, or non-zero (will fall back to network */
+int epicsRtemsMountLocalFilesystem(char **argv);
diff --git a/RTEMS/posix/rtems_config.c b/RTEMS/posix/rtems_config.c
new file mode 100644
index 0000000..8eb71eb
--- /dev/null
+++ b/RTEMS/posix/rtems_config.c
@@ -0,0 +1,88 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Saskatchewan
+* Copyright (c) 2017 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/*
+ * RTEMS configuration for EPICS
+ *      Author: W. Eric Norum
+ *              Heinz Junkes
+ *
+ * Version for RTEMS-5 and higher
+ */
+
+#include <rtems.h>
+
+/*
+ ***********************************************************************
+ *                         RTEMS CONFIGURATION                         *
+ ***********************************************************************
+ */
+
+extern void *POSIX_Init(void *argument);
+ 
+#define CONFIGURE_POSIX_INIT_THREAD_TABLE
+// Entry Point defaults to POSIX_Init
+/*
+ * nfs is using rtems tasks
+ */
+#define CONFIGURE_MAXIMUM_TASKS 		5 
+#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES    	5
+#define CONFIGURE_MAXIMUM_SEMAPHORES  		5
+#define CONFIGURE_MAXIMUM_EVENTS    		5
+
+#define CONFIGURE_MAXIMUM_POSIX_MUTEXES     	500
+#define CONFIGURE_MAXIMUM_POSIX_THREADS     	200
+#define CONFIGURE_MAXIMUM_POSIX_KEYS            200 	
+#define CONFIGURE_MAXIMUM_POSIX_KEY_VALUE_PAIRS 200 
+#define CONFIGURE_MAXIMUM_POSIX_SPINLOCKS   	100
+#define CONFIGURE_MAXIMUM_POSIX_SEMAPHORES  	300
+#define CONFIGURE_MAXIMUM_POSIX_TIMERS      	100
+#define CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES  200
+#define CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES 400
+ 
+#define CONFIGURE_UNIFIED_WORK_AREAS
+
+#define CONFIGURE_MAXIMUM_PERIODS 	5
+#define CONFIGURE_MICROSECONDS_PER_TICK 10000
+#define CONFIGURE_MALLOC_STATISTICS     1
+/* MINIMUM_STACK_SIZE == 8K */
+#define CONFIGURE_EXTRA_TASK_STACKS         (4000 * RTEMS_MINIMUM_STACK_SIZE)
+ 
+#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
+#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
+ 
+#define CONFIGURE_FILESYSTEM_DEVFS
+#define CONFIGURE_FILESYSTEM_TFTPFS
+#define CONFIGURE_FILESYSTEM_NFS
+#define CONFIGURE_FILESYSTEM_IMFS
+#define CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
+#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 150
+ 
+#define CONFIGURE_MAXIMUM_NFS_MOUNTS 		3
+#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 	5
+
+#define CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE  (64*1024)
+ 
+#define CONFIGURE_MAXIMUM_DRIVERS 8
+
+//#define CONFIGURE_INITIAL_EXTENSIONS { .fatal = fatal_extension }
+
+#define CONFIGURE_INIT
+
+
+/*
+ * This should be made BSP dependent, not CPU dependent but I know of no
+ * appropriate conditionals to use.
+ * The new general time support makes including the RTC driver less important.
+ */
+#if !defined(mpc604) && !defined(__mc68040__) && !defined(__mcf5200__) && \
+    !defined(mpc7455) && !defined(__arm__)  && !defined(__nios2__)
+    /* don't have RTC code */
+#define CONFIGURE_APPLICATION_NEEDS_RTC_DRIVER
+#endif
+
+
+#include <bsp.h>
+#include <rtems/confdefs.h>
diff --git a/RTEMS/posix/rtems_init.c b/RTEMS/posix/rtems_init.c
new file mode 100644
index 0000000..a1904e7
--- /dev/null
+++ b/RTEMS/posix/rtems_init.c
@@ -0,0 +1,796 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Saskatchewan
+* Copyright (c) 2018 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/*
+ * RTEMS startup task for EPICS
+ *      Author: W. Eric Norum
+ *              Heinz Junkes
+ *
+ * Version for RTEMS-5 and higher
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <rtems.h>
+#include <epicsVersion.h>
+#define RTEMS_VERSION_INT \
+    VERSION_INT(__RTEMS_MAJOR__, __RTEMS_MINOR__, __RTEMS_REVISION__, 0)
+#include <rtems/malloc.h>
+#include <rtems/error.h>
+#include <rtems/stackchk.h>
+#include <rtems/rtems_bsdnet.h>
+#include <rtems/imfs.h>
+#include <rtems/tftp.h>
+#include <librtemsNfs.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sched.h>
+#include <rtems/libio.h>
+#include <sys/stat.h>
+#include <termios.h>
+#include <bsp.h>
+
+#ifdef USE_GDBSTUB
+#include <rtems-gdb-stub.h>
+#endif
+
+#include "epicsThread.h"
+#include "epicsTime.h"
+#include "epicsExit.h"
+#include "envDefs.h"
+#include "errlog.h"
+#include "logClient.h"
+#include "osiUnistd.h"
+#include "iocsh.h"
+#include "osdTime.h"
+#include "epicsMemFs.h"
+
+#include "epicsRtemsInitHooks.h"
+#include <rtems/malloc.h>
+#include <rtems/score/heap.h>
+#include <pthread.h>
+#include <assert.h>
+#define rtems_test_assert(_a) assert(_a)
+
+/*
+ * Prototypes for some functions not in header files
+ */
+void tzset(void);
+int fileno(FILE *);
+int main(int argc, char **argv);
+
+static void
+logReset (void)
+{
+    void rtems_bsp_reset_cause(char *buf, size_t capacity) __attribute__((weak));
+    void (*fp)(char *buf, size_t capacity) = rtems_bsp_reset_cause;
+
+    if (fp) {
+        char buf[80];
+        fp(buf, sizeof buf);
+        errlogPrintf("Startup after %s.\n", buf);
+    }
+    else {
+       errlogPrintf("Startup.\n");
+    }
+}
+
+/*
+ ***********************************************************************
+ *                         FATAL ERROR REPORTING                       *
+ ***********************************************************************
+ */
+/*
+ * Delay for a while, then terminate
+ */
+static void
+delayedPanic (const char *msg)
+{
+    rtems_task_wake_after (rtems_clock_get_ticks_per_second());
+    rtems_task_wake_after (rtems_clock_get_ticks_per_second());
+    rtems_panic (msg);
+}
+
+/*
+ * Log error and terminate
+ */
+void
+LogFatal (const char *msg, ...)
+{
+    va_list ap;
+
+    va_start (ap, msg);
+    errlogVprintf (msg, ap);
+    va_end (ap);
+    delayedPanic (msg);
+}
+
+/*
+ * Log RTEMS error and terminate
+ */
+void
+LogRtemsFatal (const char *msg, rtems_status_code sc)
+{
+    errlogPrintf ("%s: %s\n", msg, rtems_status_text (sc));
+    delayedPanic (msg);
+}
+
+/*
+ * Log network error and terminate
+ */
+void
+LogNetFatal (const char *msg, int err)
+{
+    errlogPrintf ("%s: %d\n", msg, err);
+    delayedPanic (msg);
+}
+
+void *
+mustMalloc(int size, const char *msg)
+{
+    void *p;
+
+    if ((p = malloc (size)) == NULL)
+        LogFatal ("Can't allocate space for %s.\n", msg);
+    return p;
+}
+
+/*
+ ***********************************************************************
+ *                         REMOTE FILE ACCESS                          *
+ ***********************************************************************
+ */
+#ifdef OMIT_NFS_SUPPORT
+# include <rtems/tftp.h>
+#endif
+
+const epicsMemFS *epicsRtemsFSImage __attribute__((weak));
+const epicsMemFS *epicsRtemsFSImage = (void*)&epicsRtemsFSImage;
+
+/* hook to allow app specific FS setup */
+int
+epicsRtemsMountLocalFilesystem(char **argv) __attribute__((weak));
+int
+epicsRtemsMountLocalFilesystem(char **argv)
+{
+    if(epicsRtemsFSImage==(void*)&epicsRtemsFSImage)
+        return -1; /* no FS image provided. */
+    else if(epicsRtemsFSImage==NULL)
+        return 0; /* no FS image provided, but none is needed. */
+    else {
+        printf("***** Using compiled in file data *****\n");
+        if (epicsMemFsLoad(epicsRtemsFSImage) != 0) {
+            printf("Can't unpack tar filesystem\n");
+            return -1;
+        } else {
+            argv[1] = "/";
+            return 0;
+        }
+    }
+}
+
+static int
+initialize_local_filesystem(char **argv)
+{
+    extern char _DownloadLocation[] __attribute__((weak));
+    extern char _FlashBase[] __attribute__((weak));
+    extern char _FlashSize[]  __attribute__((weak));
+
+    argv[0] = rtems_bsdnet_bootp_boot_file_name;
+    if (epicsRtemsMountLocalFilesystem(argv)==0) {
+        return 1; /* FS setup successful */
+    } else if (_FlashSize && (_DownloadLocation || _FlashBase)) {
+        extern char _edata[];
+        size_t flashIndex = _edata - _DownloadLocation;
+        char *header = _FlashBase + flashIndex;
+
+        if (memcmp(header + 257, "ustar  ", 8) == 0) {
+            int fd;
+            printf ("***** Unpack in-memory file system (IMFS) *****\n");
+            if (rtems_tarfs_load("/", (unsigned char *)header, (size_t)_FlashSize - flashIndex) != 0) {
+                printf("Can't unpack tar filesystem\n");
+                return 0;
+            }
+            if ((fd = open(rtems_bsdnet_bootp_cmdline, 0)) >= 0) {
+                close(fd);
+                printf ("***** Found startup script (%s) in IMFS *****\n", rtems_bsdnet_bootp_cmdline);
+                argv[1] = rtems_bsdnet_bootp_cmdline;
+                return 1;
+            }
+            printf ("***** Startup script (%s) not in IMFS *****\n", rtems_bsdnet_bootp_cmdline);
+        }
+    }
+    return 0;
+}
+
+#ifndef OMIT_NFS_SUPPORT
+int
+nfsMount(char *uidhost, char *path, char *mntpoint)
+{
+    int   devl = strlen(uidhost) + strlen(path) + 2;
+    char *dev;
+    int   rval = -1;
+
+    if ((dev = malloc(devl)) == NULL) {
+        printf("nfsMount: out of memory\n");
+        return -1;
+    }
+    sprintf(dev, "%s:%s", uidhost, path);
+    rval = mount_and_make_target_path (
+        dev, mntpoint, RTEMS_FILESYSTEM_TYPE_NFS,
+        RTEMS_FILESYSTEM_READ_WRITE, NULL );
+    if(rval)
+      perror("mount failed");
+
+    free(dev);
+    return rval;
+}
+#define NFS_INIT
+#endif
+
+static void
+initialize_remote_filesystem(char **argv, int hasLocalFilesystem)
+{
+#ifndef OMIT_NFS_SUPPORT
+    char *server_name = "notDefined";
+    char *server_path = "notDefined";
+    char *mount_point = "notDefined";
+    char *cp;
+    int l = 0;
+#endif
+
+    printf ("***** Initializing TFTP *****\n");
+    if(mount_and_make_target_path("BOOTP_HOST:/",
+                               "/TFTP/BOOTP_HOST",
+                               RTEMS_FILESYSTEM_TYPE_TFTPFS,
+                               RTEMS_FILESYSTEM_READ_WRITE,
+                               NULL)) {
+        perror("mount TFTP");
+    }
+
+    if(rtems_bsdnet_bootp_cmdline && strncmp("/TFTP", rtems_bsdnet_bootp_cmdline, 4)==0) {
+        argv[1] = rtems_bsdnet_bootp_cmdline;
+        printf("Boot from TFTP\n");
+        return;
+    }
+
+    printf ("***** Initializing NFS *****\n");
+    NFS_INIT
+    if (env_nfsServer && env_nfsPath && env_nfsMountPoint) {
+        server_name = env_nfsServer;
+        server_path = env_nfsPath;
+        mount_point = env_nfsMountPoint;
+        cp = mount_point;
+        while ((cp = strchr(cp+1, '/')) != NULL) {
+            *cp = '\0';
+            if ((mkdir (mount_point, 0755) != 0)
+             && (errno != EEXIST))
+                LogFatal("Can't create directory \"%s\": %s.\n",
+                                                mount_point, strerror(errno));
+            *cp = '/';
+        }
+        argv[1] = rtems_bsdnet_bootp_cmdline;
+    }
+    else if (hasLocalFilesystem) {
+        printf("Using Local FS\n");
+        return;
+    }
+    else if (rtems_bsdnet_bootp_cmdline) {
+        /*
+         * Use first component of nvram/bootp command line pathname
+         * to set up initial NFS mount.  A "/tftpboot/" is prepended
+         * if the pathname does not begin with a '/'.  This allows
+         * NFS and TFTP to have a similar view of the remote system.
+         */
+        if (rtems_bsdnet_bootp_cmdline[0] == '/')
+            cp = rtems_bsdnet_bootp_cmdline + 1;
+        else
+            cp = rtems_bsdnet_bootp_cmdline;
+        cp = strchr(cp, '/');
+        if ((cp == NULL)
+         || ((l = cp - rtems_bsdnet_bootp_cmdline) == 0))
+            LogFatal("\"%s\" is not a valid command pathname.\n", rtems_bsdnet_bootp_cmdline);
+        cp = mustMalloc(l + 20, "NFS mount paths");
+        server_path = cp;
+        server_name = rtems_bsdnet_bootp_server_name;
+        if (rtems_bsdnet_bootp_cmdline[0] == '/') {
+            mount_point = server_path;
+            strncpy(mount_point, rtems_bsdnet_bootp_cmdline, l);
+            mount_point[l] = '\0';
+            argv[1] = rtems_bsdnet_bootp_cmdline;
+            /*
+             * Its probably common to embed the mount point in the server
+             * name so, when this is occurring, dont clobber the mount point
+             * by appending the first node from the command path. This allows
+             * the mount point to be a different path then the server's mount
+             * path.
+             *
+             * This allows for example a line similar to as follows the DHCP
+             * configuration file.
+             *
+             * server-name "159.233@192.168.0.123:/vol/vol0/bootRTEMS";
+             */
+            if ( server_name ) {
+                const size_t allocSize = strlen ( server_name ) + 2;
+                char * const pServerName = mustMalloc( allocSize,
+                                                        "NFS mount paths");
+                char * const pServerPath = mustMalloc ( allocSize,
+                                                        "NFS mount paths");
+                const int scanfStatus = sscanf (
+                                          server_name,
+                                          "%[^:] : / %s",
+                                          pServerName,
+                                          pServerPath + 1u );
+
+                if ( scanfStatus ==  2 ) {
+                    pServerPath[0u]= '/';
+                    server_name = pServerName;
+                    server_path = mount_point = pServerPath;
+                }
+                else {
+                    free ( pServerName );
+                    free ( pServerPath );
+                }
+            }
+        }
+        else {
+            char *abspath = mustMalloc(strlen(rtems_bsdnet_bootp_cmdline)+2,"Absolute command path");
+            strcpy(server_path, "/tftpboot/");
+            mount_point = server_path + strlen(server_path);
+            strncpy(mount_point, rtems_bsdnet_bootp_cmdline, l);
+            mount_point[l] = '\0';
+            mount_point--;
+            strcpy(abspath, "/");
+            strcat(abspath, rtems_bsdnet_bootp_cmdline);
+            argv[1] = abspath;
+        }
+    }
+    if(server_name && server_path && mount_point) {
+        int ret = nfsMount(server_name, server_path, mount_point);
+        printf("nfsMount(\"%s\", \"%s\", \"%s\") -> %d\n", server_name, server_path, mount_point, ret);
+
+    } else if (!hasLocalFilesystem) {
+        char *path;
+        int pathsize = 200;
+        int l;
+
+        printf("No NFS configuration found.  Falling back to TFTP\n");
+
+        path = mustMalloc(pathsize, "Command path name ");
+        strcpy (path, "/TFTP/BOOTP_HOST/epics/");
+        l = strlen (path);
+        if (gethostname (&path[l], pathsize - l - 10) || (path[l] == '\0'))
+        {
+            LogFatal ("Can't get host name");
+        }
+        strcat (path, "/st.cmd");
+        argv[1] = path;
+
+    } else {
+        printf("Local FS\n");
+    }
+}
+
+static
+char rtems_etc_hosts[] = "127.0.0.1       localhost\n";
+
+/* If it doesn't already exist, create /etc/hosts with an entry for 'localhost' */
+static
+void fixup_hosts(void)
+{
+    FILE *fp;
+    int ret;
+    struct stat STAT;
+
+    ret=stat("/etc/hosts", &STAT);
+    if(ret==0)
+    {
+        return; /* already exists, assume file */
+    } else if(errno!=ENOENT) {
+        perror("error: fixup_hosts stat /etc/hosts");
+        return;
+    }
+    ret = mkdir("/etc", 0775);
+    if(ret!=0 && errno!=EEXIST)
+    {
+        perror("error: fixup_hosts create /etc");
+        return;
+    }
+
+    if((fp=fopen("/etc/hosts", "w"))==NULL)
+    {
+        perror("error: fixup_hosts create /etc/hosts");
+    }
+
+    if(fwrite(rtems_etc_hosts, 1, sizeof(rtems_etc_hosts)-1, fp)!=sizeof(rtems_etc_hosts)-1)
+    {
+        perror("error: failed to write /etc/hosts");
+    }
+    fclose(fp);
+}
+
+/*
+ * Get to the startup script directory
+ * The TFTP filesystem requires a trailing '/' on chdir arguments.
+ */
+static void
+set_directory (const char *commandline)
+{
+    const char *cp;
+    char *directoryPath;
+    int l;
+
+    cp = strrchr(commandline, '/');
+    if (cp == NULL) {
+        l = 0;
+        cp = "/";
+    }
+    else {
+        l = cp - commandline;
+        cp = commandline;
+    }
+    directoryPath = mustMalloc(l + 2, "Command path directory ");
+    strncpy(directoryPath, cp, l);
+    directoryPath[l] = '/';
+    directoryPath[l+1] = '\0';
+    if (chdir (directoryPath) < 0)
+        LogFatal ("Can't set initial directory(%s): %s\n", directoryPath, strerror(errno));
+    else
+       free(directoryPath);
+}
+
+/*
+ ***********************************************************************
+ *                         RTEMS/EPICS COMMANDS                        *
+ ***********************************************************************
+ */
+/*
+ * RTEMS status
+ */
+static void
+rtems_netstat (unsigned int level)
+{
+    rtems_bsdnet_show_if_stats ();
+    rtems_bsdnet_show_mbuf_stats ();
+    if (level >= 1) {
+        rtems_bsdnet_show_inet_routes ();
+    }
+    if (level >= 2) {
+        rtems_bsdnet_show_ip_stats ();
+        rtems_bsdnet_show_icmp_stats ();
+        rtems_bsdnet_show_udp_stats ();
+        rtems_bsdnet_show_tcp_stats ();
+    }
+}
+
+static const iocshArg netStatArg0 = { "level",iocshArgInt};
+static const iocshArg * const netStatArgs[1] = {&netStatArg0};
+static const iocshFuncDef netStatFuncDef = {"netstat",1,netStatArgs};
+static void netStatCallFunc(const iocshArgBuf *args)
+{
+    rtems_netstat(args[0].ival);
+}
+
+static const iocshFuncDef heapSpaceFuncDef = {"heapSpace",0,NULL};
+static void heapSpaceCallFunc(const iocshArgBuf *args)
+{
+    Heap_Information_block info;
+    double x;
+
+    malloc_info (&info);
+    x = info.Stats.size - (unsigned long)
+        (info.Stats.lifetime_allocated - info.Stats.lifetime_freed);
+    if (x >= 1024*1024)
+        printf("Heap space: %.1f MB\n", x / (1024 * 1024));
+    else
+        printf("Heap space: %.1f kB\n", x / 1024);
+}
+
+#ifndef OMIT_NFS_SUPPORT
+static const iocshArg nfsMountArg0 = { "[uid.gid@]host",iocshArgString};
+static const iocshArg nfsMountArg1 = { "server path",iocshArgString};
+static const iocshArg nfsMountArg2 = { "mount point",iocshArgString};
+static const iocshArg * const nfsMountArgs[3] = {&nfsMountArg0,&nfsMountArg1,
+                                                 &nfsMountArg2};
+static const iocshFuncDef nfsMountFuncDef = {"nfsMount",3,nfsMountArgs};
+static void nfsMountCallFunc(const iocshArgBuf *args)
+{
+    char *cp = args[2].sval;
+    while ((cp = strchr(cp+1, '/')) != NULL) {
+        *cp = '\0';
+        if ((mkdir (args[2].sval, 0755) != 0) && (errno != EEXIST)) {
+            printf("Can't create directory \"%s\": %s.\n",
+                                            args[2].sval, strerror(errno));
+            return;
+        }
+        *cp = '/';
+    }
+    nfsMount(args[0].sval, args[1].sval, args[2].sval);
+}
+#endif
+
+#ifdef USE_GDBSTUB
+static const iocshArg gdbstartArg0 = { "prio",iocshArgInt};
+static const iocshArg gdbstartArg1 = { "ttyName",iocshArgString};
+static const iocshArg * const gdbstartArgs[3] = {&gdbstartArg0,&gdbstartArg1};
+static const iocshFuncDef gdbstartFuncDef = {"rtems_gdb_start",2,gdbstartArgs};
+static void gdbstartCallFunc(const iocshArgBuf *args)
+{
+    rtems_gdb_start(args[0].ival, args->sval);
+}
+
+static const iocshArg gdbstopArg0 = { "override",iocshArgInt};
+static const iocshArg * const gdbstopArgs[3] = {&gdbstopArg0};
+static const iocshFuncDef gdbstopFuncDef = {"rtems_gdb_stop",1,gdbstopArgs};
+static void gdbstopCallFunc(const iocshArgBuf *args)
+{
+    rtems_gdb_stop(args[0].ival);
+}
+#endif /* USE_GDBSTUB */
+
+/*
+ * Register RTEMS-specific commands
+ */
+static void iocshRegisterRTEMS (void)
+{
+    iocshRegister(&netStatFuncDef, netStatCallFunc);
+    iocshRegister(&heapSpaceFuncDef, heapSpaceCallFunc);
+#ifndef OMIT_NFS_SUPPORT
+    iocshRegister(&nfsMountFuncDef, nfsMountCallFunc);
+#endif
+#ifdef USE_GDBSTUB
+    iocshRegister(&gdbstartFuncDef, gdbstartCallFunc);
+    iocshRegister(&gdbstopFuncDef, gdbstopCallFunc);
+#endif
+}
+
+/*
+ * Set up the console serial line (no handshaking)
+ */
+static void
+initConsole (void)
+{
+    struct termios t;
+
+    if (tcgetattr (fileno (stdin), &t) < 0) {
+        printf ("tcgetattr failed: %s\n", strerror (errno));
+        return;
+    }
+    t.c_iflag &= ~(IXOFF | IXON | IXANY);
+    if (tcsetattr (fileno (stdin), TCSANOW, &t) < 0) {
+        printf ("tcsetattr failed: %s\n", strerror (errno));
+        return;
+    }
+}
+
+/*
+ * Hook to ensure that BSP cleanup code gets run on exit
+ */
+static void
+exitHandler(void)
+{
+    rtems_shutdown_executive(0);
+}
+
+extern char *env_rtems_gdb_stub;
+extern int epics_initialized_environment;
+extern void setBootConfigFromNVRAM(void);
+extern void bootpFallbackFromNVRAM(void);
+
+static void *
+rtemsEpicsStartUp(void *arg)
+{
+    int                 result;
+    char               *argv[3]         = { NULL, NULL, NULL };
+    char               *cp;
+    rtems_status_code   sc;
+    rtems_time_of_day   now;
+
+    /*
+     * Explain why we're here, calls errlogPrintf -> epicsThreadInit etc.
+     */
+
+    errlogSetConsole(stdout); // prevent mixup of stdout/stderr
+    logReset();
+
+    /*
+     * Architecture-specific hooks
+     */
+    if (epicsRtemsInitPreSetBootConfigFromNVRAM(&rtems_bsdnet_config) != 0)
+        delayedPanic("epicsRtemsInitPreSetBootConfigFromNVRAM");
+    epics_initialized_environment = 0;
+    setBootConfigFromNVRAM();
+    if (epicsRtemsInitPostSetBootConfigFromNVRAM(&rtems_bsdnet_config) != 0)
+        delayedPanic("epicsRtemsInitPostSetBootConfigFromNVRAM");
+
+    /*
+     * Create a reasonable environment
+     */
+    initConsole ();
+    putenv ("TERM=xterm");
+    putenv ("IOCSH_HISTSIZE=20");
+
+    if(!epics_initialized_environment) {
+        fprintf(stdout, "BSP doesn't implement non-volatile memory.\n");
+    }
+
+    /*
+     * Display some OS information
+     */
+    printf("\n***** RTEMS Version: %s *****\n",
+        rtems_get_version_string());
+
+    /*
+     * Start network
+     */
+    if ((cp = getenv("EPICS_TS_NTP_INET")) != NULL)
+        rtems_bsdnet_config.ntp_server[0] = cp;
+    if (rtems_bsdnet_config.network_task_priority == 0)
+    {
+        unsigned int p;
+        if (epicsThreadHighestPriorityLevelBelow(epicsThreadPriorityScanLow, &p)
+                                            == epicsThreadBooleanStatusSuccess)
+        {
+
+            /* This is an rtems task, so use the rtems task priority */
+            rtems_bsdnet_config.network_task_priority =
+                epicsThreadGetPosixMinPriorityValue() + epicsThreadGetPosixPriorityValue(p);
+                /* For rtems tasks, lower number = higher priority */
+
+        }
+    }
+    printf("\n***** Initializing network *****\n");
+    rtems_bsdnet_initialize_network();
+    bootpFallbackFromNVRAM();
+    printf("\n***** Setting up file system *****\n");
+    initialize_remote_filesystem(argv, initialize_local_filesystem(argv));
+    fixup_hosts();
+
+    if(env_rtems_gdb_stub) {
+#ifdef USE_GDBSTUB
+        char *arg = NULL;
+        if(strcmp(env_rtems_gdb_stub, "yes")!=0)
+            arg = env_rtems_gdb_stub;
+        printf("Start GDB server on %s\n", arg);
+        rtems_gdb_start(0,arg);
+#else
+        printf("GDB server support not enabled.\n");
+#endif
+    }
+    /*
+     * More environment: iocsh prompt and hostname
+     */
+    {
+        char hostname[1024];
+        gethostname(hostname, 1023);
+        char *cp = mustMalloc(strlen(hostname)+3, "iocsh prompt");
+        sprintf(cp, "%s> ", hostname);
+        epicsEnvSet ("IOCSH_PS1", cp);
+        epicsEnvSet("IOC_NAME", hostname);
+    }
+
+    /*
+     * Use BSP-supplied time of day if available otherwise supply default time.
+     * It is very likely that other time synchronization facilities in EPICS
+     * will soon override this value.
+     */
+    if (rtems_clock_get_tod(&now) != RTEMS_SUCCESSFUL) {
+        now.year = 2012;
+        now.month = 4;
+        now.day = 14;
+        now.hour = 7;
+        now.minute = 23;
+        now.second = 0;
+        now.ticks = 0;
+        if ((sc = rtems_clock_set (&now)) != RTEMS_SUCCESSFUL)
+            printf ("***** Can't set time: %s\n", rtems_status_text (sc));
+    }
+    if (getenv("TZ") == NULL) {
+        const char *tzp = envGetConfigParamPtr(&EPICS_TIMEZONE);
+        if (tzp == NULL) {
+            printf("Warning -- no timezone information available -- times will be displayed as GMT.\n");
+        }
+        else {
+            char tz[10];
+            int minWest, toDst = 0, fromDst = 0;
+            if(sscanf(tzp, "%9[^:]::%d:%d:%d", tz, &minWest, &toDst, &fromDst) < 2) {
+                printf("Warning: EPICS_TIMEZONE (%s) unrecognizable -- times will be displayed as GMT.\n", tzp);
+            }
+            else {
+                char posixTzBuf[40];
+                char *p = posixTzBuf;
+                p += sprintf(p, "%cST%d:%.2d", tz[0], minWest/60, minWest%60);
+                if (toDst != fromDst)
+                    p += sprintf(p, "%cDT", tz[0]);
+                epicsEnvSet("TZ", posixTzBuf);
+            }
+        }
+    }
+    tzset();
+    /* osdTimeRegister() was called during C++ initialization */
+    rtems_netstat(0);
+    /*
+     * Run the EPICS startup script
+     */
+    printf ("***** Preparing EPICS application *****\n");
+    iocshRegisterRTEMS ();
+    set_directory (argv[1]);
+    epicsEnvSet ("IOC_STARTUP_SCRIPT", argv[1]);
+    atexit(exitHandler);
+    errlogFlush();
+    printf ("***** Starting EPICS application *****\n");
+    result = main ((sizeof argv / sizeof argv[0]) - 1, argv);
+    printf ("***** IOC application terminating *****\n");
+    epicsThreadSleep(1.0);
+    epicsExit(result);
+    return NULL;
+}
+
+/*
+ * RTEMS Startup task
+ */
+void *
+POSIX_Init (void *argument)
+{
+    struct sched_param schedParam;
+    /*
+     * Override RTEMS Posix configuration, starts with posix prio 2
+     */
+
+    double maxPriority,minPriority,slope,posixPrio;
+    maxPriority = (double)sched_get_priority_max(SCHED_FIFO);
+    minPriority = (double)sched_get_priority_min(SCHED_FIFO);
+    slope = (maxPriority - minPriority)/100.0;
+    posixPrio = (double)epicsThreadPriorityIocsh * slope + minPriority;
+    schedParam.sched_priority = (int) posixPrio;
+    int s = pthread_setschedparam(pthread_self(), SCHED_FIFO, &schedParam);
+    if(s) delayedPanic ("Panix pthread_attr_setschedparam in Init ...");
+
+    rtemsMainInit(epicsThreadPriorityIocsh);
+    /* try to retrieve pthreadInfo from global list for _main_ */
+    rtemsEpicsStartUp(NULL);
+    return 0;
+}
+
+#if defined(QEMU_FIXUPS)
+/* Override some hooks (weak symbols)
+ * if BSP defaults aren't configured for running tests.
+ */
+
+
+/* Ensure that stdio goes to serial (so it can be captured) */
+#if defined(__i386__) && !USE_COM1_AS_CONSOLE
+#include <uart.h>
+extern int BSPPrintkPort;
+void bsp_predriver_hook(void)
+{
+    BSPConsolePort = BSP_CONSOLE_PORT_COM1;
+    BSPPrintkPort = BSP_CONSOLE_PORT_COM1;
+}
+#endif
+
+/* reboot immediately when done. */
+#if defined(__i386__) && BSP_PRESS_KEY_FOR_RESET
+void bsp_cleanup(void)
+{
+    void bsp_reset();
+    bsp_reset();
+}
+#endif
+
+#endif /* QEMU_FIXUPS */
+
+int cexpdebug __attribute__((weak));
diff --git a/RTEMS/posix/rtems_netconfig.c b/RTEMS/posix/rtems_netconfig.c
new file mode 100644
index 0000000..86ed527
--- /dev/null
+++ b/RTEMS/posix/rtems_netconfig.c
@@ -0,0 +1,128 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Saskatchewan
+* Copyright (c) 2017 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/*
+ * RTEMS network configuration for EPICS
+ *      Author: W. Eric Norum
+ *              Heinz Junkes
+ *
+ * Version for RTEMS-5
+ *
+ * This file can be copied to an application source dirctory
+ * and modified to override the values shown below.
+ */
+#include <stdio.h>
+#include <bsp.h>
+#include <rtems/rtems_bsdnet.h>
+
+#include "rtems_netconfig.h"
+
+#define stringOf(x) #x
+#define STRING(x) stringOf(x)
+
+/*
+ * The following configures up to 2 network interface card(s) using
+ * settings in either configure/os/CONFIG_SITE.Common.RTEMS or in a
+ * BSP-specific configure/os/CONFIG_SITE.Common.RTEMS-<bsp> file.
+ * If no settings are provided, it uses the BSP's defaults instead.
+ */
+
+#if defined(RTEMS_NETWORK_DRIVER_NAME_1)
+
+  #if defined(RTEMS_NETWORK_DRIVER_NAME_2)
+    static struct rtems_bsdnet_ifconfig netdriver_config_2 = {
+        STRING(RTEMS_NETWORK_DRIVER_NAME_2),
+    #if defined(RTEMS_NETWORK_DRIVER_ATTACH_2)
+        RTEMS_NETWORK_DRIVER_ATTACH_2,  /* specific attach function */
+    #else
+        RTEMS_BSP_NETWORK_DRIVER_ATTACH,    /* default attach function */
+    #endif
+        NULL,                               /* last interface */
+    #if defined(RTEMS_NETWORK_IP4_ADDR_2)
+        STRING(RTEMS_NETWORK_IP4_ADDR_2),
+      #if defined(RTEMS_NETWORK_IP4_MASK_2)
+        STRING(RTEMS_NETWORK_IP4_MASK_2),
+      #endif
+    #endif
+    };
+  #endif /* RTEMS_NETWORK_DRIVER_NAME_2 */
+
+  static struct rtems_bsdnet_ifconfig netdriver_config = {
+      STRING(RTEMS_NETWORK_DRIVER_NAME_1),
+  #if defined(RTEMS_NETWORK_DRIVER_ATTACH_1)
+      RTEMS_NETWORK_DRIVER_ATTACH_1,  /* specific attach function */
+  #else
+      RTEMS_BSP_NETWORK_DRIVER_ATTACH,    /* default attach function */
+  #endif
+  #if defined(RTEMS_NETWORK_DRIVER_NAME_2)
+      &netdriver_config_2,                /* link to next interface */
+  #else
+      NULL,                               /* last interface */
+  #endif
+  #if defined(RTEMS_NETWORK_IP4_ADDR_1)
+      STRING(RTEMS_NETWORK_IP4_ADDR_1),
+    #if defined(RTEMS_NETWORK_IP4_MASK_1)
+      STRING(RTEMS_NETWORK_IP4_MASK_1),
+    #endif
+  #endif
+  };
+  #define FIRST_DRIVER_CONFIG &netdriver_config
+
+#else /* RTEMS_NETWORK_DRIVER_NAME_1 */
+
+/* Use the BSP-provided standard macros */
+static struct rtems_bsdnet_ifconfig bsp_driver_config = {
+    RTEMS_BSP_NETWORK_DRIVER_NAME,      /* name */
+    RTEMS_BSP_NETWORK_DRIVER_ATTACH,    /* attach function */
+    NULL,                               /* last interface */
+};
+#define FIRST_DRIVER_CONFIG &bsp_driver_config
+
+#endif
+
+/*
+ * Allow configure/os/CONFIG_SITE.Common.RTEMS to provide domain name
+ */
+#ifdef RTEMS_NETWORK_CONFIG_DNS_DOMAINNAME
+# define MY_DOMAINNAME STRING(RTEMS_NETWORK_CONFIG_DNS_DOMAINNAME)
+#else
+# define MY_DOMAINNAME NULL
+#endif
+
+/*
+ * Allow non-BOOTP network configuration
+ */
+#ifndef MY_DO_BOOTP
+# define MY_DO_BOOTP rtems_bsdnet_do_bootp
+#endif
+
+/*
+ * Allow site- and BSP-specific network buffer space configuration.
+ * The macro values are specified in KBytes.
+ */
+#ifndef RTEMS_NETWORK_CONFIG_MBUF_SPACE
+# define RTEMS_NETWORK_CONFIG_MBUF_SPACE 180
+#endif
+#ifndef RTEMS_NETWORK_CONFIG_CLUSTER_SPACE
+# define RTEMS_NETWORK_CONFIG_CLUSTER_SPACE 350
+#endif
+
+/*
+ * Network configuration
+ */
+struct rtems_bsdnet_config rtems_bsdnet_config = {
+    FIRST_DRIVER_CONFIG,   /* Link to next interface */
+    MY_DO_BOOTP,           /* How to find network config */
+    0,                     /* If 0 then the network daemons will run at a */
+                           /*   priority just less than the lowest-priority */
+                           /*   EPICS scan thread. */
+                           /* If non-zero then the network daemons will run */
+                           /*   at this *RTEMS* priority */
+    RTEMS_NETWORK_CONFIG_MBUF_SPACE*1024,
+    RTEMS_NETWORK_CONFIG_CLUSTER_SPACE*1024,
+    NULL,                  /* Host name */
+    MY_DOMAINNAME,         /* Domain name */
+};
diff --git a/RTEMS/posix/setBootConfigFromNVRAM.c b/RTEMS/posix/setBootConfigFromNVRAM.c
new file mode 100644
index 0000000..8a93d95
--- /dev/null
+++ b/RTEMS/posix/setBootConfigFromNVRAM.c
@@ -0,0 +1,458 @@
+/*************************************************************************\
+* Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <rtems/rtems_bsdnet.h>
+#include <bsp.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <epicsStdlib.h>
+#include <epicsStdio.h>
+#include <epicsString.h>
+#include <envDefs.h>
+
+#include <osiSock.h>
+
+char *env_nfsServer;
+char *env_nfsPath;
+char *env_nfsMountPoint;
+int epics_initialized_environment;
+char *env_rtems_gdb_stub = NULL;
+
+/*
+ * Split argument string of form nfs_server:nfs_export:<path>
+ * The nfs_export component will be used as:
+ *      - the path to the directory exported from the NFS server
+ *      - the local mount point
+ *      - a prefix of <path>
+ * For example, the argument string:
+ *       romeo:/export/users:smith/ioc/iocexample/st.cmd
+ * would:
+ *       - mount /export/users from NFS server romeo on /export/users
+ *       - chdir to /export/users/smith/ioc/iocexample
+ *       - read commands from st.cmd
+ */
+static void
+splitRtemsBsdnetBootpCmdline(void)
+{
+    char *cp1, *cp2, *cp3;
+
+    if ((cp1 = rtems_bsdnet_bootp_cmdline) == NULL)
+        return;
+    if (((cp2 = strchr(cp1, ':')) != NULL)
+     && (((cp3 = strchr(cp2+1, ' ')) != NULL)
+      || ((cp3 = strchr(cp2+1, ':')) != NULL))) {
+        int l1 = cp2 - cp1;
+        int l2 = cp3 - cp2 - 1;
+        int l3 = strlen(cp3) - 1;
+        if (l1 && l2 && l3) {
+            *cp2++ = '\0';
+            *cp3 = '\0';
+            env_nfsServer = cp1;
+            env_nfsMountPoint = env_nfsPath = epicsStrDup(cp2);
+            *cp3 = '/';
+            rtems_bsdnet_bootp_cmdline = cp2;
+        }
+    }
+}
+
+/*
+ * Split NFS mount information of the form nfs_server:host_path:local_path
+ */
+static void
+splitNfsMountPath(char *nfsString)
+{
+    char *cp2, *cp3;
+
+    if (nfsString == NULL)
+        return;
+    if (((cp2 = strchr(nfsString, ':')) != NULL)
+     && (((cp3 = strchr(cp2+1, ' ')) != NULL)
+      || ((cp3 = strchr(cp2+1, ':')) != NULL))) {
+        int l1 = cp2 - nfsString;
+        int l2 = cp3 - cp2 - 1;
+        int l3 = strlen(cp3) - 1;
+        if (l1 && l2 && l3) {
+            *cp2++ = '\0';
+            *cp3++ = '\0';
+            env_nfsServer = nfsString;
+            env_nfsPath = cp2;
+            env_nfsMountPoint = cp3;
+        }
+    }
+}
+
+#if defined(HAVE_MOTLOAD)
+
+/*
+ * Motorola MOTLOAD NVRAM Access
+ */
+static char *
+gev(const char *parm, volatile char *nvp)
+{
+    const char *val;
+    const char *name;
+    char *ret;
+    char c;
+
+    for (;;) {
+        if (*nvp == '\0')
+            return NULL;
+        name = parm;
+        while ((c = *nvp++) != '\0') {
+            if ((c == '=') && (*name == '\0')) {
+                val = (char *)nvp;
+                while (*nvp++ != '\0')
+                    continue;
+                ret = malloc(nvp - val);
+                if (ret == NULL)
+                    return NULL;
+                strcpy(ret, val);
+                return ret;
+            }
+            if (c != *name++) {
+                while (*nvp++ != '\0')
+                    continue;
+                break;
+            }
+        }
+    }
+}
+
+static char *
+motScriptParm(const char *mot_script_boot, char parm)
+{
+    const char *cp;
+    char *ret;
+    int l;
+
+    while (*mot_script_boot != '\0') {
+        if (isspace(*(unsigned char *)mot_script_boot)
+         && (*(mot_script_boot+1) == '-')
+         && (*(mot_script_boot+2) == parm)) {
+            mot_script_boot += 3;
+            cp = mot_script_boot;
+            while ((*mot_script_boot != '\0') &&
+                   !isspace(*(unsigned char *)mot_script_boot))
+                mot_script_boot++;
+            l = mot_script_boot - cp;
+            ret = malloc(l+1);
+            if (ret == NULL)
+                return NULL;
+            strncpy(ret, cp, l);
+            *(ret+l) = '\0';
+            return ret;
+         }
+        mot_script_boot++;
+    }
+    return NULL;
+}
+
+void
+setBootConfigFromNVRAM(void)
+{
+    char *cp;
+    const char *mot_script_boot;
+    char *nvp;
+
+    if (rtems_bsdnet_config.bootp != NULL)
+        return;
+
+# if defined(BSP_NVRAM_BASE_ADDR)
+    nvp = (volatile unsigned char *)(BSP_NVRAM_BASE_ADDR+0x70f8);
+# elif defined(BSP_I2C_VPD_EEPROM_DEV_NAME)
+    char gev_buf[3592];
+    int fd;
+    if ((fd = open(BSP_I2C_VPD_EEPROM_DEV_NAME, 0)) < 0) {
+        printf("Can't open %s: %s\n", BSP_I2C_VPD_EEPROM_DEV_NAME, strerror(errno));
+        return;
+    }
+    lseek(fd, 0x10f8, SEEK_SET);
+    if (read(fd, gev_buf, sizeof gev_buf) != sizeof gev_buf) {
+        printf("Can't read %s: %s\n", BSP_I2C_VPD_EEPROM_DEV_NAME, strerror(errno));
+        return;
+    }
+    close(fd);
+    nvp = gev_buf;
+# else
+#  error "No way to read GEV!"
+# endif
+
+    mot_script_boot = gev("mot-script-boot", nvp);
+    if ((rtems_bsdnet_bootp_server_name = gev("mot-/dev/enet0-sipa", nvp)) == NULL)
+        rtems_bsdnet_bootp_server_name = motScriptParm(mot_script_boot, 's');
+
+    {
+        struct sockaddr_in ain;
+        aToIPAddr(rtems_bsdnet_bootp_server_name, 0, &ain);
+        rtems_bsdnet_bootp_server_address = ain.sin_addr;
+    }
+
+    if ((rtems_bsdnet_config.gateway = gev("mot-/dev/enet0-gipa", nvp)) == NULL)
+        rtems_bsdnet_config.gateway = motScriptParm(mot_script_boot, 'g');
+    if  ((rtems_bsdnet_config.ifconfig->ip_netmask = gev("mot-/dev/enet0-snma", nvp)) == NULL)
+        rtems_bsdnet_config.ifconfig->ip_netmask = motScriptParm(mot_script_boot, 'm');
+
+    rtems_bsdnet_config.name_server[0] = gev("rtems-dns-server", nvp);
+    if (rtems_bsdnet_config.name_server[0] == NULL)
+        rtems_bsdnet_config.name_server[0] = rtems_bsdnet_bootp_server_name;
+    cp = gev("rtems-dns-domainname", nvp);
+    if (cp)
+        rtems_bsdnet_config.domainname = cp;
+
+    if ((rtems_bsdnet_config.ifconfig->ip_address = gev("mot-/dev/enet0-cipa", nvp)) == NULL)
+        rtems_bsdnet_config.ifconfig->ip_address = motScriptParm(mot_script_boot, 'c');
+    rtems_bsdnet_config.hostname = gev("rtems-client-name", nvp);
+    if (rtems_bsdnet_config.hostname == NULL)
+        rtems_bsdnet_config.hostname = rtems_bsdnet_config.ifconfig->ip_address;
+
+    if ((rtems_bsdnet_bootp_boot_file_name = gev("mot-/dev/enet0-file", nvp)) == NULL)
+        rtems_bsdnet_bootp_boot_file_name = motScriptParm(mot_script_boot, 'f');
+    rtems_bsdnet_bootp_cmdline = gev("epics-script", nvp);
+    splitRtemsBsdnetBootpCmdline();
+    splitNfsMountPath(gev("epics-nfsmount", nvp));
+    rtems_bsdnet_config.ntp_server[0] = gev("epics-ntpserver", nvp);
+    if (rtems_bsdnet_config.ntp_server[0] == NULL)
+        rtems_bsdnet_config.ntp_server[0] = rtems_bsdnet_bootp_server_name;
+    if ((cp = gev("epics-tz", nvp)) != NULL)
+        epicsEnvSet("TZ", cp);
+    env_rtems_gdb_stub = gev("gdb-start", nvp);
+    epics_initialized_environment = 1;
+}
+
+#elif defined(HAVE_PPCBUG)
+/*
+ * Motorola PPCBUG NVRAM Access
+ */
+struct ppcbug_nvram {
+    uint32_t    PacketVersionIdentifier;
+    uint32_t    NodeControlMemoryAddress;
+    uint32_t    BootFileLoadAddress;
+    uint32_t    BootFileExecutionAddress;
+    uint32_t    BootFileExecutionDelay;
+    uint32_t    BootFileLength;
+    uint32_t    BootFileByteOffset;
+    uint32_t    TraceBufferAddress;
+    uint32_t    ClientIPAddress;
+    uint32_t    ServerIPAddress;
+    uint32_t    SubnetIPAddressMask;
+    uint32_t    BroadcastIPAddressMask;
+    uint32_t    GatewayIPAddress;
+    uint8_t     BootpRarpRetry;
+    uint8_t     TftpRarpRetry;
+    uint8_t     BootpRarpControl;
+    uint8_t     UpdateControl;
+    char                BootFilenameString[64];
+    char                ArgumentFilenameString[64];
+};
+
+static char *addr(char *cbuf, uint32_t addr)
+{
+    struct in_addr a;
+    if ((a.s_addr = addr) == 0)
+        return NULL;
+    return (char *)inet_ntop(AF_INET, &a, cbuf, INET_ADDRSTRLEN);
+}
+
+void
+setBootConfigFromNVRAM(void)
+{
+    static struct ppcbug_nvram nvram;
+    static char ip_address[INET_ADDRSTRLEN];
+    static char ip_netmask[INET_ADDRSTRLEN];
+    static char server[INET_ADDRSTRLEN];
+    static char gateway[INET_ADDRSTRLEN];
+
+    if (rtems_bsdnet_config.bootp != NULL)
+        return;
+
+    /*
+     * Get network configuation from PPCBUG.
+     * The 'correct' way to do this would be to issue a .NETCFIG PPCBUG
+     * system call.  Unfortunately it is very difficult to issue such a
+     * call once RTEMS is up and running so we just copy from the 'known'
+     * location of the network configuration parameters.
+     * Care must be taken to access the NVRAM a byte at a time.
+     */
+
+#if defined(NVRAM_INDIRECT)
+   {
+      volatile char *addrLo = (volatile char *)0x80000074;
+      volatile char *addrHi = (volatile char *)0x80000075;
+      volatile char *data = (volatile char *)0x80000077;
+      int addr =  0x1000;
+      char *d = (char *)&nvram;
+
+      while (d < ((char *)&nvram + sizeof nvram)) {
+         *addrLo = addr & 0xFF;
+         *addrHi = (addr >> 8) & 0xFF;
+         *d++ = *data;
+         addr++;
+      }
+   }
+#else
+    {
+    volatile char *s = (volatile char *)0xFFE81000;
+    char *d = (char *)&nvram;
+
+    while (d < ((char *)&nvram + sizeof nvram))
+        *d++ = *s++;
+    }
+#endif
+    /*
+     * Assume that the boot server is also the name, log and ntp server!
+     */
+    rtems_bsdnet_config.name_server[0] =
+    rtems_bsdnet_config.ntp_server[0]  =
+      rtems_bsdnet_bootp_server_name   = addr(server, nvram.ServerIPAddress);
+    rtems_bsdnet_bootp_server_address.s_addr = nvram.ServerIPAddress;
+    /*
+     * Nothing better to use as host name!
+     */
+    rtems_bsdnet_config.ifconfig->ip_address =
+      rtems_bsdnet_config.hostname = addr(ip_address, nvram.ClientIPAddress);
+
+    rtems_bsdnet_config.gateway = addr(gateway, nvram.GatewayIPAddress);
+    rtems_bsdnet_config.ifconfig->ip_netmask = addr(ip_netmask, nvram.SubnetIPAddressMask);
+
+    rtems_bsdnet_bootp_boot_file_name = nvram.BootFilenameString;
+    rtems_bsdnet_bootp_cmdline = nvram.ArgumentFilenameString;
+    splitRtemsBsdnetBootpCmdline();
+    epics_initialized_environment = 1;
+}
+
+#elif defined(__mcf528x__)
+
+static char *
+env(const char *parm, const char *defaultValue)
+{
+    const char *cp = bsp_getbenv(parm);
+
+    if (!cp) {
+        if (!defaultValue)
+            return NULL;
+        cp = defaultValue;
+        printf ("%s environment variable missing -- using %s.\n", parm, cp);
+    }
+    return epicsStrDup(cp);
+}
+
+void
+setBootConfigFromNVRAM(void)
+{
+    const char *cp1;
+
+    if (rtems_bsdnet_config.bootp != NULL)
+        return;
+    rtems_bsdnet_config.gateway = env("GATEWAY", NULL);
+    rtems_bsdnet_config.ifconfig->ip_netmask = env("NETMASK", "255.255.252.0");
+
+    rtems_bsdnet_bootp_server_name = env("SERVER", "192.168.0.1");
+    rtems_bsdnet_config.name_server[0] = env("NAMESERVER", rtems_bsdnet_bootp_server_name);
+    rtems_bsdnet_config.ntp_server[0] = env("NTPSERVER", rtems_bsdnet_bootp_server_name);
+    cp1 = env("DOMAIN", NULL);
+    if (cp1 != NULL)
+        rtems_bsdnet_config.domainname = cp1;
+    rtems_bsdnet_config.hostname = env("HOSTNAME", "iocNobody");
+    rtems_bsdnet_config.ifconfig->ip_address = env("IPADDR0", "192.168.0.2");
+    rtems_bsdnet_bootp_boot_file_name = env("BOOTFILE", "uC5282App.boot");
+    rtems_bsdnet_bootp_cmdline = env("CMDLINE", "epics/iocBoot/iocNobody/st.cmd");
+    splitNfsMountPath(env("NFSMOUNT", NULL));
+    if ((cp1 = env("TZ", NULL)) != NULL)
+        epicsEnvSet("TZ", cp1);
+    env_rtems_gdb_stub = env("GDBSTART", NULL);
+    epics_initialized_environment = 1;
+}
+
+#elif defined(USE_MULTIBOOT) && (__RTEMS_MAJOR__>4 || (__RTEMS_MAJOR__==4 && __RTEMS_MINOR__>9))
+
+/* Try to fill out missing BOOTP/DHCP configuration from the environment */
+void
+bootpFallbackFromNVRAM(void)
+{
+#define ENV2VAR(ENV, VAR) if(!VAR) {VAR = getenv(ENV);}
+    ENV2VAR("epics-ip",     rtems_bsdnet_config.ifconfig->ip_address);
+    ENV2VAR("epics-gw",     rtems_bsdnet_config.gateway);
+    ENV2VAR("epics-mask",   rtems_bsdnet_config.ifconfig->ip_netmask);
+    ENV2VAR("epics-dns",    rtems_bsdnet_config.name_server[0]);
+    ENV2VAR("epics-domain", rtems_bsdnet_config.domainname);
+    ENV2VAR("epics-server", rtems_bsdnet_bootp_server_name);
+    ENV2VAR("epics-client", rtems_bsdnet_config.hostname);
+    ENV2VAR("epics-script", rtems_bsdnet_bootp_cmdline);
+    ENV2VAR("epics-ntp",    rtems_bsdnet_config.ntp_server[0]);
+    ENV2VAR("gdb-start",    env_rtems_gdb_stub);
+#undef ENV2VAR
+
+    if (rtems_bsdnet_config.ntp_server[0] == NULL)
+        rtems_bsdnet_config.ntp_server[0] = rtems_bsdnet_bootp_server_name;
+
+    splitRtemsBsdnetBootpCmdline();
+    splitNfsMountPath(getenv("epics-nfsmount"));
+}
+
+void
+setBootConfigFromNVRAM(void)
+{
+    const char *mboot = bsp_cmdline();
+    size_t blen = strlen(mboot);
+    char *mboot2;
+    char *tok, *store, *save;
+
+    store = mboot2 = malloc(blen+1);
+    if(!mboot2)
+        return;
+    strcpy(mboot2, mboot);
+
+    /* Populate environment with multiboot arguments.
+     * format of multiboot string is a space seperated list of
+     * sub-strings.  eg.
+     *  "progname --arg=one --other=two otherjunk"
+     */
+
+    for(;;mboot2=NULL) {
+        char *val;
+        /* break up by space */
+        tok = strtok_r(mboot2, " ", &save);
+        if(!tok)
+            break;
+
+        /* only accept arguments starting with '--' */
+        if(tok[0]!='-' || tok[1]!='-')
+            continue;
+        tok+=2;
+
+        /* only accept arguments with an assignment */
+        val = strchr(tok, '=');
+        if(!val)
+            continue;
+        *val++ = '\0';
+
+        epicsEnvSet(tok, val);
+        printk("Set '%s' = '%s'\n", tok, val);
+    }
+
+    free(store);
+
+    epics_initialized_environment = 1;
+}
+
+#else
+/*
+ * Placeholder for systems without NVRAM
+ */
+void
+setBootConfigFromNVRAM(void)
+{
+    /* no point in printing here as the console isn't initialized... */
+}
+#endif
diff --git a/RTEMS/rtems_netconfig.h b/RTEMS/rtems_netconfig.h
new file mode 100644
index 0000000..e894f94
--- /dev/null
+++ b/RTEMS/rtems_netconfig.h
@@ -0,0 +1,7 @@
+#ifndef RTEMS_NETCONF_H
+#define RTEMS_NETCONF_H
+
+extern int
+rtems_ne2kpci_driver_attach (struct rtems_bsdnet_ifconfig *config, int attach);
+
+#endif /* RTEMS_NETCONF_H */
diff --git a/src/osi/os/RTEMS/epicsAtomicOSD.cpp b/src/osi/os/RTEMS-kernel/epicsAtomicOSD.cpp
index e69de29..e69de29 100644
--- a/src/osi/os/RTEMS/epicsAtomicOSD.cpp
+++ b/src/osi/os/RTEMS-kernel/epicsAtomicOSD.cpp
diff --git a/src/osi/os/RTEMS/epicsAtomicOSD.h b/src/osi/os/RTEMS-kernel/epicsAtomicOSD.h
index fefd201..fefd201 100644
--- a/src/osi/os/RTEMS/epicsAtomicOSD.h
+++ b/src/osi/os/RTEMS-kernel/epicsAtomicOSD.h
diff --git a/src/osi/os/RTEMS/osdEvent.c b/src/osi/os/RTEMS-kernel/osdEvent.c
index 4554138..4554138 100644
--- a/src/osi/os/RTEMS/osdEvent.c
+++ b/src/osi/os/RTEMS-kernel/osdEvent.c
diff --git a/src/osi/os/RTEMS/osdEvent.h b/src/osi/os/RTEMS-kernel/osdEvent.h
index 6c53aad..6c53aad 100644
--- a/src/osi/os/RTEMS/osdEvent.h
+++ b/src/osi/os/RTEMS-kernel/osdEvent.h
diff --git a/src/osi/os/RTEMS/osdFindSymbol.c b/src/osi/os/RTEMS-kernel/osdFindSymbol.c
index 9e947f9..9e947f9 100644
--- a/src/osi/os/RTEMS/osdFindSymbol.c
+++ b/src/osi/os/RTEMS-kernel/osdFindSymbol.c
diff --git a/src/osi/os/RTEMS/osdMessageQueue.c b/src/osi/os/RTEMS-kernel/osdMessageQueue.c
index a566de6..a566de6 100644
--- a/src/osi/os/RTEMS/osdMessageQueue.c
+++ b/src/osi/os/RTEMS-kernel/osdMessageQueue.c
diff --git a/src/osi/os/RTEMS/osdMessageQueue.h b/src/osi/os/RTEMS-kernel/osdMessageQueue.h
index 0244a1f..0244a1f 100644
--- a/src/osi/os/RTEMS/osdMessageQueue.h
+++ b/src/osi/os/RTEMS-kernel/osdMessageQueue.h
diff --git a/src/osi/os/RTEMS/osdMutex.c b/src/osi/os/RTEMS-kernel/osdMutex.c
index 96fde6e..96fde6e 100644
--- a/src/osi/os/RTEMS/osdMutex.c
+++ b/src/osi/os/RTEMS-kernel/osdMutex.c
diff --git a/src/osi/os/RTEMS/osdMutex.h b/src/osi/os/RTEMS-kernel/osdMutex.h
index 7e2ecc7..7e2ecc7 100644
--- a/src/osi/os/RTEMS/osdMutex.h
+++ b/src/osi/os/RTEMS-kernel/osdMutex.h
diff --git a/src/osi/os/RTEMS/osdPoolStatus.c b/src/osi/os/RTEMS-kernel/osdPoolStatus.c
index b2f4011..b2f4011 100644
--- a/src/osi/os/RTEMS/osdPoolStatus.c
+++ b/src/osi/os/RTEMS-kernel/osdPoolStatus.c
diff --git a/src/osi/os/RTEMS/osdProcess.c b/src/osi/os/RTEMS-kernel/osdProcess.c
index 2768dbb..2768dbb 100644
--- a/src/osi/os/RTEMS/osdProcess.c
+++ b/src/osi/os/RTEMS-kernel/osdProcess.c
diff --git a/src/osi/os/RTEMS/osdReadline.c b/src/osi/os/RTEMS-kernel/osdReadline.c
index 877db53..877db53 100644
--- a/src/osi/os/RTEMS/osdReadline.c
+++ b/src/osi/os/RTEMS-kernel/osdReadline.c
diff --git a/src/osi/os/RTEMS/osdSignal.cpp b/src/osi/os/RTEMS-kernel/osdSignal.cpp
index 08dfa02..08dfa02 100644
--- a/src/osi/os/RTEMS/osdSignal.cpp
+++ b/src/osi/os/RTEMS-kernel/osdSignal.cpp
diff --git a/src/osi/os/RTEMS/osdSock.h b/src/osi/os/RTEMS-kernel/osdSock.h
index 6177c30..6177c30 100644
--- a/src/osi/os/RTEMS/osdSock.h
+++ b/src/osi/os/RTEMS-kernel/osdSock.h
diff --git a/src/osi/os/RTEMS/osdSpin.c b/src/osi/os/RTEMS-kernel/osdSpin.c
index 7a45468..7a45468 100644
--- a/src/osi/os/RTEMS/osdSpin.c
+++ b/src/osi/os/RTEMS-kernel/osdSpin.c
diff --git a/src/osi/os/RTEMS/osdStrtod.h b/src/osi/os/RTEMS-kernel/osdStrtod.h
index 39fda69..39fda69 100644
--- a/src/osi/os/RTEMS/osdStrtod.h
+++ b/src/osi/os/RTEMS-kernel/osdStrtod.h
diff --git a/src/osi/os/RTEMS/osdThread.c b/src/osi/os/RTEMS-kernel/osdThread.c
index 769e958..769e958 100644
--- a/src/osi/os/RTEMS/osdThread.c
+++ b/src/osi/os/RTEMS-kernel/osdThread.c
diff --git a/src/osi/os/RTEMS/osdThread.h b/src/osi/os/RTEMS-kernel/osdThread.h
index 4451f84..4451f84 100644
--- a/src/osi/os/RTEMS/osdThread.h
+++ b/src/osi/os/RTEMS-kernel/osdThread.h
diff --git a/src/osi/os/RTEMS/osdThreadExtra.c b/src/osi/os/RTEMS-kernel/osdThreadExtra.c
index 0a7c7ae..0a7c7ae 100644
--- a/src/osi/os/RTEMS/osdThreadExtra.c
+++ b/src/osi/os/RTEMS-kernel/osdThreadExtra.c
diff --git a/src/osi/os/RTEMS/osdTime.cpp b/src/osi/os/RTEMS-kernel/osdTime.cpp
index 1350c1c..1350c1c 100644
--- a/src/osi/os/RTEMS/osdTime.cpp
+++ b/src/osi/os/RTEMS-kernel/osdTime.cpp
diff --git a/src/osi/os/RTEMS/osdTime.h b/src/osi/os/RTEMS-kernel/osdTime.h
index 55e3bc2..55e3bc2 100644
--- a/src/osi/os/RTEMS/osdTime.h
+++ b/src/osi/os/RTEMS-kernel/osdTime.h
diff --git a/src/osi/os/RTEMS/osiUnistd.h b/src/osi/os/RTEMS-kernel/osiUnistd.h
index c0a6e22..c0a6e22 100644
--- a/src/osi/os/RTEMS/osiUnistd.h
+++ b/src/osi/os/RTEMS-kernel/osiUnistd.h
diff --git a/src/osi/os/RTEMS-posix/osdInterrupt.c b/src/osi/os/RTEMS-posix/osdInterrupt.c
new file mode 100644
index 0000000..4d4ead6
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdInterrupt.c
@@ -0,0 +1,59 @@
+/*************************************************************************\
+* Copyright (c) 2009 UChicago Argonne LLC, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/* osi/default/osdInterrupt.c */
+
+/* Author:  Marty Kraimer Date:    15JUL99 */
+
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#define epicsExportSharedSymbols
+#include "epicsMutex.h"
+#include "epicsThread.h"
+#include "cantProceed.h"
+#include "errlog.h"
+#include "epicsInterrupt.h"
+
+#include <rtems/bspIo.h>
+#include <rtems.h>
+
+epicsShareFunc int epicsInterruptLock()
+{
+    rtems_interrupt_level level;
+
+    rtems_interrupt_disable (level);
+    return level;
+}
+
+epicsShareFunc void epicsInterruptUnlock(int key)
+{
+    rtems_interrupt_level level = key;
+
+    rtems_interrupt_enable (level);
+}
+
+epicsShareFunc int epicsInterruptIsInterruptContext()
+{
+        return rtems_interrupt_is_in_progress ();
+}
+
+epicsShareFunc void epicsInterruptContextMessage(const char *message)
+{
+    printk("%s", message);
+}
+
+
+
+
+
+
+
diff --git a/src/osi/os/RTEMS-posix/osdMessageQueue.cpp b/src/osi/os/RTEMS-posix/osdMessageQueue.cpp
new file mode 100644
index 0000000..b763da1
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdMessageQueue.cpp
@@ -0,0 +1,163 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* Copyright (c) 2017 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/*
+ *      Author  W. Eric Norum
+ *              Heinz Junkes
+ *
+ * Adapted to rtems4.12
+ *   -> posix message queues 
+ *   remove all internal calls (_xxx), remove e.g. Objects_Locations etc.
+ */
+
+/*
+ * We want to access information which is
+ * normally hidden from application programs.
+ */
+#define __RTEMS_VIOLATE_KERNEL_VISIBILITY__ 1
+
+#define epicsExportSharedSymbols
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <rtems.h>
+#include <rtems/error.h>
+#include "epicsMessageQueue.h"
+#include "errlog.h"
+#include <epicsAtomic.h>
+
+#include <errno.h>
+#include <mqueue.h>
+#include <fcntl.h>
+
+epicsShareFunc epicsMessageQueueId epicsShareAPI
+epicsMessageQueueCreate(unsigned int capacity, unsigned int maximumMessageSize)
+{
+  struct mq_attr the_attr;
+  epicsMessageQueueId id = (epicsMessageQueueId)calloc(1, sizeof(*id));
+
+  epicsAtomicIncrIntT(&id->idCnt);
+  sprintf(id->name, "MQ_%010d",epicsAtomicGetIntT(&id->idCnt));    
+  the_attr.mq_maxmsg = capacity;
+  the_attr.mq_msgsize = maximumMessageSize;
+  id->id = mq_open(id->name, O_RDWR | O_CREAT | O_EXCL, 0644, &the_attr);
+  if (id->id < 0) { 
+    errlogPrintf ("Can't create message queue: %s\n", strerror (errno));
+    return NULL;
+  }
+  return id;
+}
+
+epicsShareFunc void epicsShareAPI epicsMessageQueueDestroy(
+    epicsMessageQueueId id)
+{
+  int rv;
+  rv = mq_close(id->id);
+  if( rv ) { 
+    errlogPrintf("epicsMessageQueueDestroy mq_close failed: %s\n",
+                         strerror(rv));
+  }
+  rv = mq_unlink(id->name);
+  if( rv ) { 
+    errlogPrintf("epicsMessageQueueDestroy mq_unlink %s failed: %s\n",
+                         id->name, strerror(rv));
+  }
+  free(id);
+}
+
+epicsShareFunc int epicsShareAPI epicsMessageQueueTrySend(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int messageSize)
+{
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  return mq_timedsend(id->id, (char const *)message, messageSize, 0, &ts); 
+}
+
+epicsShareFunc int epicsShareAPI epicsMessageQueueSendWithTimeout(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int messageSize,
+    double timeout)
+{
+  struct timespec ts;
+  unsigned long micros;
+    
+  // assume timeout in sec
+  micros = (unsigned long)(timeout * 1000000.0);
+  clock_gettime(CLOCK_REALTIME, &ts);
+  ts.tv_sec += micros / 1000000L;
+  ts.tv_nsec += (micros % 1000000L) * 1000L;
+
+  return  mq_timedsend (id->id, (const char *)message, messageSize, 0, &ts);
+}
+
+epicsShareFunc int epicsShareAPI epicsMessageQueueTryReceive(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int size)
+{
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    return mq_timedreceive(id->id, (char *)message, size, NULL, &ts);
+}
+
+epicsShareFunc int epicsShareAPI epicsMessageQueueReceiveWithTimeout(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int size,
+    double timeout)
+{
+    unsigned long micros;
+    struct timespec ts;
+    
+    micros = (unsigned long)(timeout * 1000000.0);
+    clock_gettime(CLOCK_REALTIME, &ts);
+    ts.tv_sec += micros / 1000000L;
+    ts.tv_nsec += (micros % 1000000L) * 1000L;
+
+    return mq_timedreceive(id->id, (char *)message, size, NULL, &ts);
+}
+
+epicsShareFunc int epicsShareAPI epicsMessageQueuePending(
+            epicsMessageQueueId id)
+{
+  int rv;
+  struct mq_attr the_attr;
+
+  rv = mq_getattr(id->id, &the_attr);    
+  if (rv) {
+    errlogPrintf("Epics Message queue %x (%s) get attr failed: %s\n",
+                         (unsigned int)id->id, id->name, strerror(rv));
+        return -1;
+    }
+    return the_attr.mq_curmsgs;
+}
+
+epicsShareFunc void epicsShareAPI epicsMessageQueueShow(
+            epicsMessageQueueId id,
+                int level)
+{
+  int rv;
+  struct mq_attr the_attr;
+
+  rv = mq_getattr(id->id, &the_attr);    
+  if (rv) {
+    errlogPrintf("Epics Message queue %x (%s) get attr failed: %s\n",
+                         (unsigned int)id->id, id->id, strerror(rv));
+    }
+
+    printf("Message Queue Used:%ld  Max Msg:%lu", the_attr.mq_curmsgs, the_attr.mq_maxmsg);
+    if (level >= 1)
+       printf("  Maximum size:%lu", the_attr.mq_msgsize);
+
+    printf("\n");
+}
diff --git a/src/osi/os/RTEMS-posix/osdMessageQueue.h b/src/osi/os/RTEMS-posix/osdMessageQueue.h
new file mode 100644
index 0000000..fccb2d2
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdMessageQueue.h
@@ -0,0 +1,31 @@
+/*************************************************************************\
+ * * Copyright (c) 2002 The University of Chicago, as Operator of Argonne
+ * *     National Laboratory.
+ * * Copyright (c) 2002 The Regents of the University of California, as
+ * *     Operator of Los Alamos National Laboratory.
+ * * Copyright (c) 2017 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+ * * EPICS BASE is distributed subject to a Software License Agreement found
+ * * in file LICENSE that is included with this distribution.
+ * \*************************************************************************/
+/*
+ *      Author  W. Eric Norum
+ *              Heinz Junkes
+ *
+ * Eric's note : Very thin shims around vxWorks routines
+ *
+ * Adapted to rtems4.12
+ *   -> posix message queues 
+ */
+
+#include <rtems.h>
+#include <mqueue.h>
+
+struct epicsMessageQueueOSD {
+    mqd_t id;
+    char  name[24];
+    int	  idCnt;
+
+};
+
+#define epicsMessageQueueSend(q,m,l) (mq_send((q)->id, (const char*)(m), (l), 0))
+#define epicsMessageQueueReceive(q,m,s) (mq_receive((q)->id, (char*)(m), (s), NULL))
diff --git a/src/osi/os/RTEMS-posix/osdMutex.c b/src/osi/os/RTEMS-posix/osdMutex.c
new file mode 100644
index 0000000..7f4aa62
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdMutex.c
@@ -0,0 +1,6 @@
+#include <rtems.h>
+#include <rtems/error.h>
+#include <rtems/rtems/tasks.h>
+#include <rtems/score/threadimpl.h>
+
+#include "../posix/osdMutex.c"
diff --git a/src/osi/os/RTEMS-posix/osdPoolStatus.c b/src/osi/os/RTEMS-posix/osdPoolStatus.c
new file mode 100644
index 0000000..cdd8941
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdPoolStatus.c
@@ -0,0 +1,34 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* Copyright (c) 2017 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+
+/*
+ *     Heinz Junkes
+ *     Adapted to rtems4.12
+ */
+
+#include <rtems.h>
+#include <rtems/malloc.h>
+#include <rtems/score/heap.h>
+#define epicsExportSharedSymbols
+#include "osiPoolStatus.h"
+
+/*
+ * osiSufficentSpaceInPool ()
+ * 
+ */
+epicsShareFunc int epicsShareAPI osiSufficentSpaceInPool ( size_t contiguousBlockSize )
+{
+    unsigned long n;
+    Heap_Information_block info;
+
+    malloc_info( &info );
+    n = info.Stats.size - (unsigned long)(info.Stats.lifetime_allocated - info.Stats.lifetime_freed);
+    return (n > (50000 + contiguousBlockSize));
+}
diff --git a/src/osi/os/RTEMS-posix/osdSock.h b/src/osi/os/RTEMS-posix/osdSock.h
new file mode 100644
index 0000000..103cdd7
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdSock.h
@@ -0,0 +1,112 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Saskatchewan
+* Copyright (c) 2017 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+/*
+ * RTEMS osdSock.h
+ *      Author: W. Eric Norum
+ *              Heinz Junkes
+ *
+ * Adapted to rtems4.12
+ */
+#ifndef osdSockH
+#define osdSockH
+
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <ifaddrs.h> /* getifaddrs() */
+#include <unistd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int select(int  n,  fd_set  *readfds,  fd_set  *writefds, fd_set *exceptfds, struct timeval *timeout);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#ifndef IPPORT_USERRESERVED
+#define IPPORT_USERRESERVED 5000
+#endif
+
+#define USE_IFADDRS
+
+typedef int                     SOCKET;
+#define INVALID_SOCKET          (-1)
+#define SOCKERRNO               errno
+#define socket_ioctl(A,B,C)     ioctl(A,B,C)
+typedef int osiSockIoctl_t;
+typedef socklen_t osiSocklen_t;
+
+typedef char osiSockOptMcastLoop_t;
+
+#define FD_IN_FDSET(FD) ((FD)<FD_SETSIZE)
+
+#define SOCK_EWOULDBLOCK EWOULDBLOCK
+#define SOCK_ENOBUFS ENOBUFS
+#define SOCK_ECONNRESET ECONNRESET
+#define SOCK_ETIMEDOUT ETIMEDOUT
+#define SOCK_EACCES EACCES
+#define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
+#define SOCK_ECONNREFUSED ECONNREFUSED
+#define SOCK_ECONNABORTED ECONNABORTED
+#define SOCK_EINPROGRESS EINPROGRESS
+#define SOCK_EISCONN EISCONN
+#define SOCK_EALREADY EALREADY
+#define SOCK_EINVAL EINVAL
+#define SOCK_EINTR EINTR
+#define SOCK_EPIPE EPIPE
+#define SOCK_EMFILE EMFILE
+#define SOCK_SHUTDOWN EPIPE
+#define SOCK_ENOTSOCK ENOTSOCK
+#define SOCK_EBADF EBADF
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#ifndef INADDR_LOOPBACK
+#define       INADDR_LOOPBACK         (u_long)0x7F000001
+#endif
+
+#ifndef INADDR_NONE
+#   define INADDR_NONE (0xffffffff)
+#endif
+
+/*
+ * For shutdown()
+ */
+#ifndef SHUT_RD
+#   define SHUT_RD 0
+#endif
+
+#ifndef SHUT_WR
+#   define SHUT_WR 1
+#endif
+
+#ifndef SHUT_RDWR
+#   define SHUT_RDWR 2
+#endif
+
+/*
+ * Ensure that we get the right network code in default/osdNetIntf.c.
+ */
+#define ifreq_size(pifreq) (pifreq->ifr_addr.sa_len + sizeof(pifreq->ifr_name))
+
+#endif /*osdSockH*/
diff --git a/src/osi/os/RTEMS-posix/osdThread.c b/src/osi/os/RTEMS-posix/osdThread.c
new file mode 100644
index 0000000..2b51fdb
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdThread.c
@@ -0,0 +1,1042 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* Copyright (c) 2013 ITER Organization.
+* Copyright (c) 2017 Fritz-Haber-Institut der Max-Planck-Gesellschaft
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/* Author:  Marty Kraimer Date:    18JAN2000
+   	    Heinz Junkes  Date:    06APR2017
+*/
+
+/* This is a posix implementation of epicsThread */
+#include <stddef.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <time.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sched.h>
+#include <unistd.h>
+
+#define XSTR(x) STR(x)
+#define STR(x) #x
+
+#if defined(__rtems__)
+/* RTEMS defines _POSIX_MEMLOCK as 1 in features.h which is wrong */
+#undef _POSIX_MEMLOCK
+#endif
+
+#if defined(_POSIX_MEMLOCK) && _POSIX_MEMLOCK > 0
+#include <sys/mman.h>
+#endif
+
+#define epicsExportSharedSymbols
+#include "epicsStdio.h"
+#include "ellLib.h"
+#include "epicsEvent.h"
+#include "epicsMutex.h"
+#include "epicsString.h"
+#include "epicsThread.h"
+#include "cantProceed.h"
+#include "errlog.h"
+#include "epicsAssert.h"
+#include "epicsExit.h"
+
+epicsShareFunc void epicsThreadShowInfo(epicsThreadOSD *pthreadInfo, unsigned int level);
+epicsShareFunc void osdThreadHooksRun(epicsThreadId id);
+epicsShareFunc void osdThreadHooksRunMain(epicsThreadId id);
+
+static int mutexLock(pthread_mutex_t *id)
+{
+    int status;
+
+    while(1) {
+        status = pthread_mutex_lock(id);
+        if(status!=EINTR) return status;
+        fprintf(stderr,"pthread_mutex_lock returned EINTR. Violates SUSv3\n");
+    }
+}
+
+#if defined DONT_USE_POSIX_THREAD_PRIORITY_SCHEDULING
+#undef _POSIX_THREAD_PRIORITY_SCHEDULING
+#endif
+
+typedef struct commonAttr{
+    pthread_attr_t     attr;
+    struct sched_param schedParam;
+    int                maxPriority;
+    int                minPriority;
+    int                schedPolicy;
+    int                usePolicy;
+} commonAttr;
+
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+typedef struct {
+    int min_pri, max_pri;
+    int policy;
+    int ok;
+} priAvailable;
+#endif
+
+static pthread_key_t getpthreadInfo;
+static pthread_mutex_t onceLock;
+static pthread_mutex_t listLock;
+static ELLLIST pthreadList = ELLLIST_INIT;
+static commonAttr *pcommonAttr = 0;
+static int epicsThreadOnceCalled = 0;
+

+static epicsThreadOSD *createImplicit(void);
+
+#define checkStatus(status, message) \
+    if ((status))  {\
+        errlogPrintf("%s error %s\n", (message), strerror((status))); \
+    }
+
+#define checkStatusQuit(status, message, method) \
+    if ((status)) { \
+        errlogPrintf("%s error %s\n", (message), strerror((status))); \
+        cantProceed((method)); \
+    }
+
+/* The following are for use in once, which is only invoked from epicsThreadInit
+ * Until epicsThreadInit completes errlogInit will not work.
+ * They must also be used in init_threadInfo otherwise errlogInit could get
+ * called recursively.
+ */
+#define checkStatusOnce(status, message) \
+    if ((status))  {\
+        fprintf(stderr, "%s error %s\n", (message), strerror((status))); \
+    }
+
+#define checkStatusOnceQuit(status, message, method) \
+    if ((status)) { \
+        fprintf(stderr, "%s error %s", (message), strerror((status))); \
+        fprintf(stderr, "in %s\n", (method)); \
+        fprintf(stderr, "epicsThreadInit can't proceed. Program exiting\n"); \
+        exit(-1); \
+    }
+
+epicsShareFunc int epicsThreadGetPosixPriority(epicsThreadId pthreadInfo)
+{
+   assert(epicsThreadOnceCalled);
+   return(epicsThreadGetPosixPriorityValue(pthreadInfo->osiPriority));
+}
+
+static void setSchedulingPolicy(epicsThreadOSD *pthreadInfo,int policy)
+{
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    int status;
+
+    if (!pcommonAttr->usePolicy) return;
+
+    status = pthread_attr_getschedparam(
+        &pthreadInfo->attr,&pthreadInfo->schedParam);
+    checkStatusOnce(status,"pthread_attr_getschedparam");
+
+    pthreadInfo->schedParam.sched_priority = epicsThreadGetPosixPriority(pthreadInfo);
+    pthreadInfo->schedPolicy = policy;
+    status = pthread_attr_setschedpolicy(
+        &pthreadInfo->attr,policy);
+    checkStatusOnce(status,"pthread_attr_setschedpolicy");
+
+    status = pthread_attr_setschedparam(
+        &pthreadInfo->attr,&pthreadInfo->schedParam);
+    checkStatusOnce(status,"pthread_attr_setschedparam");
+
+    status = pthread_attr_setinheritsched(
+        &pthreadInfo->attr,PTHREAD_EXPLICIT_SCHED);
+    checkStatusOnce(status,"pthread_attr_setinheritsched");
+#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+}
+

+static epicsThreadOSD * create_threadInfo(const char *name)
+{
+    epicsThreadOSD *pthreadInfo;
+
+    /* sizeof(epicsThreadOSD) includes one byte for the '\0' */
+    pthreadInfo = calloc(1,sizeof(*pthreadInfo) + strlen(name));
+    if(!pthreadInfo)
+        return NULL;
+
+    pthreadInfo->suspendEvent = epicsEventCreate(epicsEventEmpty);
+    if(!pthreadInfo->suspendEvent){
+        free(pthreadInfo);
+        return NULL;
+    }
+
+    strcpy(pthreadInfo->name, name);
+    return pthreadInfo;
+}
+
+static epicsThreadOSD * init_threadInfo(const char *name,
+    unsigned int priority, unsigned int stackSize,
+    EPICSTHREADFUNC funptr,void *parm)
+{
+    epicsThreadOSD *pthreadInfo;
+    int status;
+
+    pthreadInfo = create_threadInfo(name);
+    if(!pthreadInfo)
+        return NULL;
+
+    pthreadInfo->createFunc = funptr;
+    pthreadInfo->createArg = parm;
+    status = pthread_attr_init(&pthreadInfo->attr);
+    checkStatusOnce(status,"pthread_attr_init");
+    if(status) return 0;
+
+    status = pthread_attr_setdetachstate(
+        &pthreadInfo->attr, PTHREAD_CREATE_DETACHED);
+    checkStatusOnce(status,"pthread_attr_setdetachstate");
+#if defined (_POSIX_THREAD_ATTR_STACKSIZE)
+#if ! defined (OSITHREAD_USE_DEFAULT_STACK)
+    status = pthread_attr_setstacksize( &pthreadInfo->attr,(size_t)stackSize);
+    checkStatusOnce(status,"pthread_attr_setstacksize");
+#endif /*OSITHREAD_USE_DEFAULT_STACK*/
+#endif /*_POSIX_THREAD_ATTR_STACKSIZE*/
+    status = pthread_attr_setscope(&pthreadInfo->attr,PTHREAD_SCOPE_PROCESS);
+    if(errVerbose) checkStatusOnce(status,"pthread_attr_setscope");
+    pthreadInfo->osiPriority = priority;
+#if defined (__rtems__)
+    /*
+     on rtems startup (posix mode) once get called first
+     by POSIX_Global_construction
+        -> Thread_Global)construction
+        -> ppc_interrupt_disable
+        -> init(asm)
+        -> __do_global_ctors)aux(asm)
+        -> GLOBAL__sub_I_iocshPpdbbase
+        -> __static_initialization_adn_destruction_0
+        -> IochRegister
+        -> localRegister
+        -> iocshRegister
+        -> iocshTableLock
+        -> epicsThreadOnce
+        -> epicsThreadInit
+        -> Once
+        -> once()
+     *
+     * Then all keys etc. get cleaned and Posix_Init gets called.
+     epicsThreadGetIdSelf failed ... createImplicit gets called and
+     a new pthreadInfo is created for _main_
+
+    if (strcmp(name, "_main_")) {
+        fprintf(stderr," set _main_ paramtere\n");
+        pthreadInfo->isRealTimeScheduled = 1;
+        pthreadInfo->isEpicsThread = 1;
+        pthreadInfo->tid = pthread_self();
+        fprintf(stderr, "tid = 0x%x\n", pthreadInfo->tid);
+        pthreadInfo->osiPriority = posixThreadGetOsiPriorityValue(pthreadInfo->tid);
+    }
+     */
+#endif
+
+    return(pthreadInfo);
+}
+
+static void free_threadInfo(epicsThreadOSD *pthreadInfo)
+{
+    int status;
+
+    if(pthreadInfo->isOnThreadList) {
+      status = mutexLock(&listLock);
+      checkStatusQuit(status,"pthread_mutex_lock","free_threadInfo");
+      ellDelete(&pthreadList,&pthreadInfo->node);
+      status = pthread_mutex_unlock(&listLock);
+      checkStatusQuit(status,"pthread_mutex_unlock","free_threadInfo");
+    }
+    epicsEventDestroy(pthreadInfo->suspendEvent);
+    status = pthread_attr_destroy(&pthreadInfo->attr);
+    checkStatusQuit(status,"pthread_attr_destroy","free_threadInfo");
+    free(pthreadInfo);
+}
+

+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+/*
+ * The actually available range priority range (at least under linux)
+ * may be restricted by resource limitations (but that is ignored
+ * by sched_get_priority_max()). See bug #835138 which is fixed by
+ * this code.
+ */
+static int try_pri(int pri, int policy)
+{
+struct sched_param  schedp;
+    schedp.sched_priority = pri;
+    return pthread_setschedparam(pthread_self(), policy, &schedp);
+}
+
+static void*
+find_pri_range(void *arg)
+{
+priAvailable *prm = arg;
+int           min = sched_get_priority_min(prm->policy);
+int           max = sched_get_priority_max(prm->policy);
+int           low, try;
+
+    if ( -1 == min || -1 == max ) {
+        /* something is very wrong; maintain old behavior
+         * (warning message if sched_get_priority_xxx() fails
+         * and use default policy's sched_priority [even if
+         * that is likely to cause epicsThreadCreate to fail
+         * because that priority is not suitable for SCHED_FIFO]).
+         */
+        prm->min_pri = prm->max_pri = -1;
+        return 0;
+    }
+
+
+    if ( try_pri(min, prm->policy) ) {
+        /* cannot create thread at minimum priority;
+         * probably no permission to use SCHED_FIFO
+         * at all. However, we still must return
+         * a priority range accepted by the SCHED_FIFO
+         * policy. Otherwise, epicsThreadCreate() cannot
+         * detect the unsufficient permission (EPERM)
+         * and fall back to a non-RT thread (because
+         * pthread_attr_setschedparam would fail with
+         * EINVAL due to the bad priority).
+         */
+        prm->min_pri = prm->max_pri = min;
+        return 0;
+    }
+
+
+    /* Binary search through available priorities.
+     * The actually available range may be restricted
+     * by resource limitations (but that is ignored
+     * by sched_get_priority_max() [linux]).
+     */
+    low = min;
+
+    while ( low < max ) {
+        try = (max+low)/2;
+        if ( try_pri(try, prm->policy) ) {
+            max = try;
+        } else {
+            low = try + 1;
+        }
+    }
+
+    prm->min_pri = min;
+    prm->max_pri = try_pri(max, prm->policy) ? max-1 : max;
+    prm->ok = 1;
+
+    return 0;
+}
+
+static void findPriorityRange(commonAttr *a_p)
+{
+priAvailable arg;
+pthread_t    id;
+void         *dummy;
+int          status;
+
+    arg.policy = a_p->schedPolicy;
+    arg.ok = 0;
+
+    status = pthread_create(&id, 0, find_pri_range, &arg);
+    checkStatusOnceQuit(status, "pthread_create","findPriorityRange");
+
+    status = pthread_join(id, &dummy);
+    checkStatusOnceQuit(status, "pthread_join","findPriorityRange");
+    a_p->minPriority = arg.min_pri;
+    a_p->maxPriority = arg.max_pri;
+    a_p->usePolicy = arg.ok;
+}
+#endif
+

+
+static void once(void)
+{
+    int status;
+    status = pthread_key_create(&getpthreadInfo,0);
+    checkStatusOnceQuit(status,"pthread_key_create","once");
+    status = pthread_mutex_init(&onceLock,0);
+    checkStatusOnceQuit(status,"pthread_mutex_init","once");
+    status = pthread_mutex_init(&listLock,0);
+    checkStatusOnceQuit(status,"pthread_mutex_init","once");
+    pcommonAttr = calloc(1,sizeof(commonAttr));
+    if(!pcommonAttr) checkStatusOnceQuit(errno,"calloc","once");
+    status = pthread_attr_init(&pcommonAttr->attr);
+    checkStatusOnceQuit(status,"pthread_attr_init","once");
+    status = pthread_attr_setdetachstate(
+        &pcommonAttr->attr, PTHREAD_CREATE_DETACHED);
+    checkStatusOnce(status,"pthread_attr_setdetachstate");
+    status = pthread_attr_setscope(&pcommonAttr->attr,PTHREAD_SCOPE_PROCESS);
+    if(errVerbose) checkStatusOnce(status,"pthread_attr_setscope");
+
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    status = pthread_attr_setschedpolicy(
+        &pcommonAttr->attr,SCHED_FIFO);
+    checkStatusOnce(status,"pthread_attr_setschedpolicy");
+    status = pthread_attr_getschedpolicy(
+        &pcommonAttr->attr,&pcommonAttr->schedPolicy);
+    checkStatusOnce(status,"pthread_attr_getschedpolicy");
+    status = pthread_attr_getschedparam(
+        &pcommonAttr->attr,&pcommonAttr->schedParam);
+    checkStatusOnce(status,"pthread_attr_getschedparam");
+
+    findPriorityRange(pcommonAttr);
+
+    if(pcommonAttr->maxPriority == -1) {
+        pcommonAttr->maxPriority = pcommonAttr->schedParam.sched_priority;
+        fprintf(stderr,"sched_get_priority_max failed set to %d\n",
+            pcommonAttr->maxPriority);
+    }
+    if(pcommonAttr->minPriority == -1) {
+        pcommonAttr->minPriority = pcommonAttr->schedParam.sched_priority;
+        fprintf(stderr,"sched_get_priority_min failed set to %d\n",
+            pcommonAttr->maxPriority);
+    }
+
+    if (errVerbose) {
+        fprintf(stderr, "LRT: min priority: %d max priority %d\n",
+            pcommonAttr->minPriority, pcommonAttr->maxPriority);
+    }
+#else
+    if(errVerbose) {
+      fprintf(stderr,"task priorities are not implemented\n");
+    }
+#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+
+#if !defined(__rtems__)
+    epicsThreadOSD *pthreadInfo;
+    pthreadInfo = init_threadInfo("_main_",0, epicsThreadGetStackSize(epicsThreadStackSmall),0,0);
+    assert(pthreadInfo!=NULL);
+    status = pthread_setspecific(getpthreadInfo,(void *)pthreadInfo);
+    checkStatusOnceQuit(status,"pthread_setspecific","once");
+    status = mutexLock(&listLock);
+    checkStatusOnceQuit(status,"pthread_mutex_lock","once");
+    ellAdd(&pthreadList,&pthreadInfo->node);
+    pthreadInfo->isOnThreadList = 1;
+    status = pthread_mutex_unlock(&listLock);
+    checkStatusOnceQuit(status,"pthread_mutex_unlock","once");
+#endif
+    status = atexit(epicsExitCallAtExits);
+    checkStatusOnce(status,"atexit");
+#if !defined(__rtems__)
+    osdThreadHooksRunMain(pthreadInfo);
+#endif
+    epicsThreadOnceCalled = 1;
+}
+
+#if defined(__rtems__)
+epicsShareFunc
+void rtemsMainInit(int prio)
+{
+    int status;
+    epicsThreadOSD *pthreadInfo;
+
+    pthreadInfo = init_threadInfo("_main_", prio,
+        epicsThreadGetStackSize(epicsThreadStackSmall), 0, 0);
+    assert(pthreadInfo!=NULL);
+
+    pthreadInfo->isRealTimeScheduled = 1;
+    pthreadInfo->isEpicsThread = 1;
+    pthreadInfo->tid = pthread_self();
+    pthreadInfo->osiPriority = posixThreadGetOsiPriorityValue(pthreadInfo->tid);
+
+    status = pthread_setspecific(getpthreadInfo,(void *)pthreadInfo);
+    checkStatusOnceQuit(status,"pthread_setspecific","rtemsMainInit");
+
+    status = mutexLock(&listLock);
+    checkStatusOnceQuit(status,"pthread_mutex_lock","once");
+
+    ellAdd(&pthreadList,&pthreadInfo->node);
+    pthreadInfo->isOnThreadList = 1;
+    status = pthread_mutex_unlock(&listLock);
+    checkStatusOnceQuit(status,"pthread_mutex_unlock","rtemsMainInit");
+}
+#endif
+
+static void * start_routine(void *arg)
+{
+    epicsThreadOSD *pthreadInfo = (epicsThreadOSD *)arg;
+    int status;
+    sigset_t blockAllSig;
+
+    sigfillset(&blockAllSig);
+    pthread_sigmask(SIG_SETMASK,&blockAllSig,NULL);
+    status = pthread_setspecific(getpthreadInfo,arg);
+    checkStatusQuit(status,"pthread_setspecific","start_routine");
+    status = mutexLock(&listLock);
+    checkStatusQuit(status,"pthread_mutex_lock","start_routine");
+    ellAdd(&pthreadList,&pthreadInfo->node);
+    pthreadInfo->isOnThreadList = 1;
+    status = pthread_mutex_unlock(&listLock);
+    checkStatusQuit(status,"pthread_mutex_unlock","start_routine");
+    osdThreadHooksRun(pthreadInfo);
+
+    (*pthreadInfo->createFunc)(pthreadInfo->createArg);
+
+    epicsExitCallAtThreadExits ();
+    free_threadInfo(pthreadInfo);
+    return(0);
+}
+
+static void epicsThreadInit(void)
+{
+    static pthread_once_t once_control = PTHREAD_ONCE_INIT;
+    int status = pthread_once(&once_control,once);
+    checkStatusQuit(status,"pthread_once","epicsThreadInit");
+}
+
+epicsShareFunc
+void epicsThreadRealtimeLock(void)
+{
+#if defined(_POSIX_MEMLOCK) && _POSIX_MEMLOCK > 0
+    if (pcommonAttr->maxPriority > pcommonAttr->minPriority) {
+        int status = mlockall(MCL_CURRENT | MCL_FUTURE);
+
+        if (status) {
+            fprintf(stderr, "epicsThreadRealtimeLock "
+                "Warning: Unable to lock the virtual address space.\n"
+                "VM page faults may harm real-time performance.\n");
+        }
+    }
+#endif
+}
+
+epicsShareFunc unsigned int epicsShareAPI epicsThreadGetStackSize (epicsThreadStackSizeClass stackSizeClass)
+{
+#if defined (OSITHREAD_USE_DEFAULT_STACK)
+    return 0;
+#elif defined(_POSIX_THREAD_ATTR_STACKSIZE) && _POSIX_THREAD_ATTR_STACKSIZE > 0
+#if defined (__rtems__)
+    #define STACK_SIZE(f) (f * 0x1000 * sizeof(void *))
+#else
+    #define STACK_SIZE(f) (f * 0x10000 * sizeof(void *))
+#endif
+    static const unsigned stackSizeTable[epicsThreadStackBig+1] = {
+        STACK_SIZE(1), STACK_SIZE(2), STACK_SIZE(4)
+    };
+    if (stackSizeClass<epicsThreadStackSmall) {
+        errlogPrintf("epicsThreadGetStackSize illegal argument (too small)");
+        return stackSizeTable[epicsThreadStackBig];
+    }
+
+    if (stackSizeClass>epicsThreadStackBig) {
+        errlogPrintf("epicsThreadGetStackSize illegal argument (too large)");
+        return stackSizeTable[epicsThreadStackBig];
+    }
+
+    return stackSizeTable[stackSizeClass];
+#else
+    return 0;
+#endif /*_POSIX_THREAD_ATTR_STACKSIZE*/
+}
+

+epicsShareFunc void epicsShareAPI epicsThreadOnce(epicsThreadOnceId *id, void (*func)(void *), void *arg)
+{
+    static struct epicsThreadOSD threadOnceComplete;
+    #define EPICS_THREAD_ONCE_DONE &threadOnceComplete
+    int status;
+
+    epicsThreadInit();
+    status = mutexLock(&onceLock);
+    if(status) {
+        fprintf(stderr,"epicsThreadOnce: pthread_mutex_lock returned %s.\n",
+                strerror(status));
+        exit(-1);
+    }
+
+    if (*id != EPICS_THREAD_ONCE_DONE) {
+        if (*id == EPICS_THREAD_ONCE_INIT) { /* first call */
+            *id = epicsThreadGetIdSelf();    /* mark active */
+            status = pthread_mutex_unlock(&onceLock);
+            checkStatusOnceQuit(status,"pthread_mutex_unlock", "epicsThreadOnce");
+            func(arg);
+            status = mutexLock(&onceLock);
+            checkStatusOnceQuit(status,"pthread_mutex_lock", "epicsThreadOnce");
+            *id = EPICS_THREAD_ONCE_DONE;    /* mark done */
+        } else if (*id == epicsThreadGetIdSelf()) {
+            status = pthread_mutex_unlock(&onceLock);
+            checkStatusOnceQuit(status,"pthread_mutex_unlock", "epicsThreadOnce");
+            cantProceed("Recursive epicsThreadOnce() initialization\n");
+        } else
+            while (*id != EPICS_THREAD_ONCE_DONE) {
+                /* Another thread is in the above func(arg) call. */
+                status = pthread_mutex_unlock(&onceLock);
+                checkStatusOnceQuit(status,"pthread_mutex_unlock", "epicsThreadOnce");
+                epicsThreadSleep(epicsThreadSleepQuantum());
+                status = mutexLock(&onceLock);
+                checkStatusOnceQuit(status,"pthread_mutex_lock", "epicsThreadOnce");
+            }
+    }
+    status = pthread_mutex_unlock(&onceLock);
+    checkStatusOnceQuit(status,"pthread_mutex_unlock","epicsThreadOnce");
+}
+
+epicsShareFunc epicsThreadId epicsShareAPI epicsThreadCreate(const char *name,
+    unsigned int priority, unsigned int stackSize,
+    EPICSTHREADFUNC funptr,void *parm)
+{
+    epicsThreadOSD *pthreadInfo;
+    int status;
+    sigset_t blockAllSig, oldSig;
+
+    epicsThreadInit();
+    assert(pcommonAttr);
+    sigfillset(&blockAllSig);
+    pthread_sigmask(SIG_SETMASK,&blockAllSig,&oldSig);
+    pthreadInfo = init_threadInfo(name,priority,stackSize,funptr,parm);
+    if(pthreadInfo==0) return 0;
+    pthreadInfo->isEpicsThread = 1;
+    setSchedulingPolicy(pthreadInfo,SCHED_FIFO);
+    pthreadInfo->isRealTimeScheduled = 1;
+    status = pthread_create(&pthreadInfo->tid,&pthreadInfo->attr,
+                start_routine,pthreadInfo);
+    if(status==EPERM){
+        /* Try again without SCHED_FIFO*/
+        free_threadInfo(pthreadInfo);
+        pthreadInfo = init_threadInfo(name,priority,stackSize,funptr,parm);
+        if(pthreadInfo==0) return 0;
+        pthreadInfo->isEpicsThread = 1;
+        status = pthread_create(&pthreadInfo->tid,&pthreadInfo->attr,
+                start_routine,pthreadInfo);
+    }
+    checkStatusOnce(status,"pthread_create");
+    if(status) {
+        free_threadInfo(pthreadInfo);
+        return 0;
+    }
+    status = pthread_sigmask(SIG_SETMASK,&oldSig,NULL);
+    checkStatusOnce(status,"pthread_sigmask");
+    return(pthreadInfo);
+}
+
+/*
+ * Create dummy context for threads not created by epicsThreadCreate().
+ */
+static epicsThreadOSD *createImplicit(void)
+{
+    epicsThreadOSD *pthreadInfo;
+    char name[64];
+    pthread_t tid;
+    int status;
+
+    tid = pthread_self();
+    sprintf(name, "non-EPICS_%08ld", (long)tid);
+    pthreadInfo = create_threadInfo(name);
+    assert(pthreadInfo);
+    pthreadInfo->tid = tid;
+#if defined(__rtems__)
+    pthreadInfo->osiPriority = posixThreadGetOsiPriorityValue(tid);
+#endif
+    status = pthread_setspecific(getpthreadInfo,(void *)pthreadInfo);
+    checkStatus(status,"pthread_setspecific createImplicit");
+    if(status){
+        free_threadInfo(pthreadInfo);
+        return NULL;
+    }
+    return pthreadInfo;
+}
+

+epicsShareFunc void epicsShareAPI epicsThreadSuspendSelf(void)
+{
+    epicsThreadOSD *pthreadInfo;
+
+    epicsThreadInit();
+    pthreadInfo = (epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
+    if(pthreadInfo==NULL)
+        pthreadInfo = createImplicit();
+    pthreadInfo->isSuspended = 1;
+    epicsEventWait(pthreadInfo->suspendEvent);
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadResume(epicsThreadOSD *pthreadInfo)
+{
+    assert(epicsThreadOnceCalled);
+    pthreadInfo->isSuspended = 0;
+    epicsEventSignal(pthreadInfo->suspendEvent);
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadExitMain(void)
+{
+    epicsThreadOSD *pthreadInfo;
+
+    epicsThreadInit();
+    pthreadInfo = (epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
+    if(pthreadInfo==NULL)
+        pthreadInfo = createImplicit();
+    if(pthreadInfo->createFunc) {
+        errlogPrintf("called from non-main thread\n");
+        cantProceed("epicsThreadExitMain");
+    }
+    else {
+    free_threadInfo(pthreadInfo);
+    pthread_exit(0);
+    }
+}
+
+epicsShareFunc int posixThreadGetOsiPriorityValue(pthread_t tid)
+{
+ #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    struct sched_param param;
+    int policy;
+
+    if (pthread_getschedparam(tid,&policy,&param) == 0) {
+        return (param.sched_priority - pcommonAttr->minPriority) * 100.0 /
+            (pcommonAttr->maxPriority - pcommonAttr->minPriority + 1);
+    }
+#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+    return 0;
+}
+
+epicsShareFunc int epicsThreadGetPosixPriorityValue(int osiPriority)
+{
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    double maxPriority, minPriority, slope, posixPrio;
+
+    if (pcommonAttr->maxPriority==pcommonAttr->minPriority)
+        return pcommonAttr->maxPriority;
+
+    maxPriority = (double)pcommonAttr->maxPriority;
+    minPriority = (double)pcommonAttr->minPriority;
+    slope = (maxPriority - minPriority)/100.0;
+    posixPrio = (double)osiPriority * slope + minPriority;
+    return (int) posixPrio;
+#else
+    return 0;
+#endif
+}
+
+epicsShareFunc unsigned int epicsShareAPI epicsThreadGetPosixMaxPriorityValue()
+{
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    return pcommonAttr->maxPriority;
+#else
+    return 0;
+#endif
+}
+epicsShareFunc unsigned int epicsShareAPI epicsThreadGetPosixMinPriorityValue()
+{
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    return pcommonAttr->minPriority;
+#else
+    return 0;
+#endif
+}
+
+epicsShareFunc unsigned int epicsShareAPI epicsThreadGetPriority(epicsThreadId pthreadInfo)
+{
+    assert(epicsThreadOnceCalled);
+    return pthreadInfo->osiPriority;
+}
+
+epicsShareFunc unsigned int epicsShareAPI epicsThreadGetPrioritySelf(void)
+{
+    epicsThreadInit();
+    return epicsThreadGetPriority(epicsThreadGetIdSelf());
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadSetPriority(epicsThreadId pthreadInfo,unsigned int priority)
+{
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    int status;
+#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+
+    assert(epicsThreadOnceCalled);
+    assert(pthreadInfo);
+
+#if !defined (__rtems__)
+    if (!pthreadInfo->isEpicsThread) {
+        fprintf(stderr, "epicsThreadSetPriority called for non-EPICS thread\n");
+        return;
+    }
+#endif
+    pthreadInfo->osiPriority = priority;
+    if (!pthreadInfo->isRealTimeScheduled) return;
+
+#if defined (_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    if(!pcommonAttr->usePolicy) return;
+    pthreadInfo->schedParam.sched_priority = epicsThreadGetPosixPriority(pthreadInfo);
+    status = pthread_attr_setschedparam(
+        &pthreadInfo->attr,&pthreadInfo->schedParam);
+    if(errVerbose) checkStatus(status,"pthread_attr_setschedparam");
+    status = pthread_setschedparam(
+        pthreadInfo->tid, pthreadInfo->schedPolicy, &pthreadInfo->schedParam);
+    if(errVerbose) checkStatus(status,"pthread_setschedparam");
+#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+}
+
+epicsShareFunc epicsThreadBooleanStatus epicsShareAPI epicsThreadHighestPriorityLevelBelow(
+    unsigned int priority, unsigned *pPriorityJustBelow)
+{
+    unsigned newPriority = priority - 1;
+
+    epicsThreadInit();
+    assert(pcommonAttr);
+
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    int diff;
+    diff = pcommonAttr->maxPriority - pcommonAttr->minPriority;
+    if(diff<0) diff = -diff;
+    if(diff>1 && diff <100) newPriority -=  100/(diff+1);
+#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+    if (newPriority <= 99) {
+        *pPriorityJustBelow = newPriority;
+        return epicsThreadBooleanStatusSuccess;
+    }
+    return epicsThreadBooleanStatusFail;
+}
+
+epicsShareFunc epicsThreadBooleanStatus epicsShareAPI epicsThreadLowestPriorityLevelAbove(
+    unsigned int priority, unsigned *pPriorityJustAbove)
+{
+    unsigned newPriority = priority + 1;
+
+    epicsThreadInit();
+    assert(pcommonAttr);
+
+#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
+    int diff;
+    diff = pcommonAttr->maxPriority - pcommonAttr->minPriority;
+    if(diff<0) diff = -diff;
+    if(diff>1 && diff <100) newPriority += 100/(diff+1);
+#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+
+    if (newPriority <= 99) {
+        *pPriorityJustAbove = newPriority;
+        return epicsThreadBooleanStatusSuccess;
+    }
+    return epicsThreadBooleanStatusFail;
+}
+

+epicsShareFunc int epicsShareAPI epicsThreadIsEqual(epicsThreadId p1, epicsThreadId p2)
+{
+    assert(epicsThreadOnceCalled);
+    assert(p1);
+    assert(p2);
+    return(pthread_equal(p1->tid,p2->tid));
+}
+
+epicsShareFunc int epicsShareAPI epicsThreadIsSuspended(epicsThreadId pthreadInfo) {
+    assert(epicsThreadOnceCalled);
+    assert(pthreadInfo);
+    return(pthreadInfo->isSuspended ? 1 : 0);
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadSleep(double seconds)
+{
+    struct timespec delayTime;
+    struct timespec remainingTime;
+    double nanoseconds;
+
+    if (seconds > 0) {
+        delayTime.tv_sec = seconds;
+        nanoseconds = (seconds - delayTime.tv_sec) *1e9;
+        delayTime.tv_nsec = nanoseconds;
+    }
+    else {
+        delayTime.tv_sec = 0;
+        delayTime.tv_nsec = 0;
+    }
+    while (nanosleep(&delayTime, &remainingTime) == -1 &&
+           errno == EINTR)
+        delayTime = remainingTime;
+}
+
+epicsShareFunc epicsThreadId epicsShareAPI epicsThreadGetIdSelf(void) {
+    epicsThreadOSD *pthreadInfo;
+
+    epicsThreadInit();
+    pthreadInfo = (epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
+    if(pthreadInfo==NULL)
+        pthreadInfo = createImplicit();
+    assert( pthreadInfo );
+    return(pthreadInfo);
+}
+
+epicsShareFunc pthread_t epicsThreadGetPosixThreadId ( epicsThreadId threadId )
+{
+    return threadId->tid;
+}
+
+epicsShareFunc epicsThreadId epicsShareAPI epicsThreadGetId(const char *name) {
+    epicsThreadOSD *pthreadInfo;
+    int status;
+
+    assert(epicsThreadOnceCalled);
+    status = mutexLock(&listLock);
+    checkStatus(status,"pthread_mutex_lock epicsThreadGetId");
+    if(status)
+        return NULL;
+    pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
+    while (pthreadInfo) {
+        if (strcmp(name,pthreadInfo->name) == 0) break;
+        pthreadInfo = (epicsThreadOSD *)ellNext(&pthreadInfo->node);
+    }
+    status = pthread_mutex_unlock(&listLock);
+    checkStatus(status,"pthread_mutex_unlock epicsThreadGetId");
+
+    return(pthreadInfo);
+}
+
+epicsShareFunc const char epicsShareAPI *epicsThreadGetNameSelf()
+{
+    epicsThreadOSD *pthreadInfo;
+
+    epicsThreadInit();
+    pthreadInfo=(epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
+    if(pthreadInfo==NULL)
+        pthreadInfo = createImplicit();
+    return(pthreadInfo->name);
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadGetName(epicsThreadId pthreadInfo, char *name, size_t size)
+{
+    assert(epicsThreadOnceCalled);
+    strncpy(name, pthreadInfo->name, size-1);
+    name[size-1] = '\0';
+}
+

+epicsShareFunc void epicsThreadMap(EPICS_THREAD_HOOK_ROUTINE func)
+{
+    epicsThreadOSD *pthreadInfo;
+    int status;
+
+    epicsThreadInit();
+    status = mutexLock(&listLock);
+    checkStatus(status, "pthread_mutex_lock epicsThreadMap");
+    if (status)
+        return;
+    pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
+    while (pthreadInfo) {
+        func(pthreadInfo);
+        pthreadInfo = (epicsThreadOSD *)ellNext(&pthreadInfo->node);
+    }
+    status = pthread_mutex_unlock(&listLock);
+    checkStatus(status, "pthread_mutex_unlock epicsThreadMap");
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadShowAll(unsigned int level)
+{
+    epicsThreadOSD *pthreadInfo;
+    int status;
+
+    epicsThreadInit();
+    epicsThreadShow(0,level);
+    status = mutexLock(&listLock);
+    checkStatus(status,"pthread_mutex_lock epicsThreadShowAll");
+    if(status)
+        return;
+    pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
+    while(pthreadInfo) {
+        epicsThreadShowInfo(pthreadInfo,level);
+        pthreadInfo=(epicsThreadOSD *)ellNext(&pthreadInfo->node);
+    }
+    status = pthread_mutex_unlock(&listLock);
+    checkStatus(status,"pthread_mutex_unlock epicsThreadShowAll");
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadShow(epicsThreadId showThread, unsigned int level)
+{
+    epicsThreadOSD *pthreadInfo;
+    int status;
+    int found = 0;
+
+    epicsThreadInit();
+    if(!showThread) {
+        epicsThreadShowInfo(0,level);
+        return;
+    }
+    status = mutexLock(&listLock);
+    checkStatus(status,"pthread_mutex_lock epicsThreadShow");
+    if(status)
+        return;
+    pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
+    while(pthreadInfo) {
+        if (((epicsThreadId)pthreadInfo == showThread)
+         || ((epicsThreadId)pthreadInfo->tid == showThread)) {
+            found = 1;
+            epicsThreadShowInfo(pthreadInfo,level);
+        }
+        pthreadInfo=(epicsThreadOSD *)ellNext(&pthreadInfo->node);
+    }
+    status = pthread_mutex_unlock(&listLock);
+    checkStatus(status,"pthread_mutex_unlock epicsThreadShow");
+    if(status) return;
+    if (!found)
+        printf("Thread %#lx (%lu) not found.\n", (unsigned long)showThread, (unsigned long)showThread);
+}
+

+epicsShareFunc epicsThreadPrivateId epicsShareAPI epicsThreadPrivateCreate(void)
+{
+    pthread_key_t *key;
+    int status;
+
+    epicsThreadInit();
+    key = calloc(1,sizeof(pthread_key_t));
+    if(!key)
+        return NULL;
+    status = pthread_key_create(key,0);
+    checkStatus(status,"pthread_key_create epicsThreadPrivateCreate");
+    if(status)
+        return NULL;
+    return((epicsThreadPrivateId)key);
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadPrivateDelete(epicsThreadPrivateId id)
+{
+    pthread_key_t *key = (pthread_key_t *)id;
+    int status;
+
+    assert(epicsThreadOnceCalled);
+    status = pthread_key_delete(*key);
+    checkStatusQuit(status,"pthread_key_delete","epicsThreadPrivateDelete");
+    free((void *)key);
+}
+
+epicsShareFunc void epicsShareAPI epicsThreadPrivateSet (epicsThreadPrivateId id, void *value)
+{
+    pthread_key_t *key = (pthread_key_t *)id;
+    int status;
+
+    assert(epicsThreadOnceCalled);
+    if(errVerbose && !value)
+        errlogPrintf("epicsThreadPrivateSet: setting value of 0\n");
+    status = pthread_setspecific(*key,value);
+    checkStatusQuit(status,"pthread_setspecific","epicsThreadPrivateSet");
+}
+
+epicsShareFunc void epicsShareAPI *epicsThreadPrivateGet(epicsThreadPrivateId id)
+{
+    pthread_key_t *key = (pthread_key_t *)id;
+
+    assert(epicsThreadOnceCalled);
+    return pthread_getspecific(*key);
+}
+
+epicsShareFunc double epicsShareAPI epicsThreadSleepQuantum ()
+{
+    double hz;
+    hz = sysconf ( _SC_CLK_TCK );
+    if(hz<0)
+        return 0.0;
+    return 1.0 / hz;
+}
+
+epicsShareFunc int epicsThreadGetCPUs(void)
+{
+    long ret;
+#ifdef _SC_NPROCESSORS_ONLN
+    ret = sysconf(_SC_NPROCESSORS_ONLN);
+    if (ret > 0)
+        return ret;
+#endif
+#ifdef _SC_NPROCESSORS_CONF
+    ret = sysconf(_SC_NPROCESSORS_CONF);
+    if (ret > 0)
+        return ret;
+#endif
+    return 1;
+}
diff --git a/src/osi/os/RTEMS-posix/osdThread.h b/src/osi/os/RTEMS-posix/osdThread.h
new file mode 100644
index 0000000..ac27ff0
--- /dev/null
+++ b/src/osi/os/RTEMS-posix/osdThread.h
@@ -0,0 +1,55 @@
+/*************************************************************************\
+* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE Versions 3.13.7
+* and higher are distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+#ifndef osdThreadh
+#define osdThreadh
+
+#include <pthread.h>
+
+#include "shareLib.h"
+#include "ellLib.h"
+#include "epicsEvent.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct epicsThreadOSD {
+    ELLNODE            node;
+    pthread_t          tid;
+    pthread_attr_t     attr;
+    struct sched_param schedParam;
+    int                schedPolicy;
+    EPICSTHREADFUNC    createFunc;
+    void              *createArg;
+    epicsEventId       suspendEvent;
+    int                isSuspended;
+    int                isEpicsThread;
+    int                isRealTimeScheduled;
+    int                isOnThreadList;
+    unsigned int       osiPriority;
+    char               name[1];     /* actually larger */
+} epicsThreadOSD;
+
+epicsShareFunc pthread_t epicsThreadGetPosixThreadId(epicsThreadId id);
+epicsShareFunc int epicsThreadGetPosixPriority(epicsThreadId id);
+epicsShareFunc int epicsThreadGetPosixPriorityValue(int osiPriority);
+epicsShareFunc int posixThreadGetOsiPriorityValue(pthread_t tid);
+epicsShareFunc unsigned int epicsShareAPI epicsThreadGetPosixMaxPriorityValue();
+epicsShareFunc unsigned int epicsShareAPI epicsThreadGetPosixMinPriorityValue();
+
+#if defined(__rtems__)
+epicsShareFunc void rtemsMainInit(int prio);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* osdThreadh */