Enable Epics for RTEMS5 (posix)

modules/libcom/src/osi/os/RTEMS-kernel/osdMessageQueue.c

@@ -0,0 +1,251 @@
+/*************************************************************************\
+* 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. 
+\*************************************************************************/
+/*
+ *      Author  W. Eric Norum
+ *              norume@aps.anl.gov
+ *              630 252 4793
+ */
+
+/*
+ * 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"
+
+LIBCOM_API epicsMessageQueueId epicsStdCall
+epicsMessageQueueCreate(unsigned int capacity, unsigned int maximumMessageSize)
+{
+    rtems_status_code sc;
+    epicsMessageQueueId id = calloc(1, sizeof(*id));
+    rtems_interrupt_level level;
+    static char c1 = 'a';
+    static char c2 = 'a';
+    static char c3 = 'a';
+
+    if(!id)
+        return NULL;
+    
+    sc = rtems_message_queue_create (rtems_build_name ('Q', c3, c2, c1),
+        capacity,
+        maximumMessageSize,
+        RTEMS_FIFO|RTEMS_LOCAL,
+        &id->id);
+    if (sc != RTEMS_SUCCESSFUL) {
+        free(id);
+        errlogPrintf ("Can't create message queue: %s\n", rtems_status_text (sc));
+        return NULL;
+    }
+    id->maxSize = maximumMessageSize;
+    id->localBuf = NULL;
+    rtems_interrupt_disable (level);
+    if (c1 == 'z') {
+        if (c2 == 'z') {
+            if (c3 == 'z') {
+                c3 = 'a';
+            }
+            else {
+                c3++;
+            }
+            c2 = 'a';
+        }
+        else {
+            c2++;
+        }
+        c1 = 'a';
+    }
+    else {
+        c1++;
+    }
+    rtems_interrupt_enable (level);
+    return id;
+}
+
+static rtems_status_code rtems_message_queue_send_timeout(
+    rtems_id id,
+    void *buffer,
+    uint32_t size,
+    rtems_interval timeout)
+{
+  Message_queue_Control    *the_message_queue;
+  Objects_Locations         location;
+  CORE_message_queue_Status msg_status;
+    
+  the_message_queue = _Message_queue_Get( id, &location );
+  switch ( location )
+  {
+    case OBJECTS_ERROR:
+      return RTEMS_INVALID_ID;
+
+    case OBJECTS_LOCAL:
+      msg_status = _CORE_message_queue_Send(
+        &the_message_queue->message_queue,
+        buffer,
+        size,
+        id,
+        NULL,
+        1,
+        timeout
+      );
+
+      _Thread_Enable_dispatch();
+
+      /*
+       *  If we had to block, then this is where the task returns
+       *  after it wakes up.  The returned status is correct for
+       *  non-blocking operations but if we blocked, then we need 
+       *  to look at the status in our TCB.
+       */
+
+      if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
+        msg_status = _Thread_Executing->Wait.return_code;
+      return _Message_queue_Translate_core_message_queue_return_code( msg_status );
+  }
+  return RTEMS_INTERNAL_ERROR;   /* unreached - only to remove warnings */
+}
+
+LIBCOM_API int epicsStdCall epicsMessageQueueSend(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int messageSize)
+{
+    if (rtems_message_queue_send_timeout(id->id, message, messageSize, RTEMS_NO_TIMEOUT) == RTEMS_SUCCESSFUL)
+        return 0;
+    else
+        return -1;
+}
+
+LIBCOM_API int epicsStdCall epicsMessageQueueSendWithTimeout(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int messageSize,
+    double timeout)
+{
+    rtems_interval delay;
+    extern double rtemsTicksPerSecond_double;
+    
+    /*
+     * Convert time to ticks
+     */
+    if (timeout <= 0.0)
+        return epicsMessageQueueTrySend(id, message, messageSize);
+    delay = (int)(timeout * rtemsTicksPerSecond_double);
+    if (delay == 0)
+        delay++;
+    if (rtems_message_queue_send_timeout(id->id, message, messageSize, delay) == RTEMS_SUCCESSFUL)
+        return 0;
+    else
+        return -1;
+}
+
+static int receiveMessage(
+    epicsMessageQueueId id,
+    void *buffer,
+    uint32_t size,
+    uint32_t wait,
+    rtems_interval delay)
+{
+    size_t rsize;
+    rtems_status_code sc;
+    
+    if (size < id->maxSize) {
+        if (id->localBuf == NULL) {
+            id->localBuf = malloc(id->maxSize);
+            if (id->localBuf == NULL)
+                return -1;
+        }
+        rsize = receiveMessage(id, id->localBuf, id->maxSize, wait, delay);
+        if (rsize > size)
+            return -1;
+        memcpy(buffer, id->localBuf, rsize);
+    }
+    else {
+        sc = rtems_message_queue_receive(id->id, buffer, &rsize, wait, delay);
+        if (sc != RTEMS_SUCCESSFUL)
+            return -1;
+    }
+    return rsize;
+}
+
+LIBCOM_API int epicsStdCall epicsMessageQueueTryReceive(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int size)
+{
+    return receiveMessage(id, message, size, RTEMS_NO_WAIT, 0);
+}
+
+LIBCOM_API int epicsStdCall epicsMessageQueueReceive(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int size)
+{
+    return receiveMessage(id, message, size, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
+}
+
+LIBCOM_API int epicsStdCall epicsMessageQueueReceiveWithTimeout(
+    epicsMessageQueueId id,
+    void *message,
+    unsigned int size,
+    double timeout)
+{
+    rtems_interval delay;
+    uint32_t wait;
+    extern double rtemsTicksPerSecond_double;
+    
+    /*
+     * Convert time to ticks
+     */
+    if (timeout <= 0.0) {
+        wait = RTEMS_NO_WAIT;
+        delay = 0;
+    }
+    else {
+        wait = RTEMS_WAIT;
+        delay = (int)(timeout * rtemsTicksPerSecond_double);
+        if (delay == 0)
+            delay++;
+    }
+    return receiveMessage(id, message, size, wait, delay);
+}
+
+LIBCOM_API int epicsStdCall epicsMessageQueuePending(
+            epicsMessageQueueId id)
+{
+    uint32_t count;
+    rtems_status_code sc;
+    
+    sc = rtems_message_queue_get_number_pending(id->id, &count);
+    if (sc != RTEMS_SUCCESSFUL) {
+        errlogPrintf("Message queue %x get number pending failed: %s\n",
+                                                        (unsigned int)id,
+                                                        rtems_status_text(sc));
+        return -1;
+    }
+    return count;
+}
+
+LIBCOM_API void epicsStdCall epicsMessageQueueShow(
+            epicsMessageQueueId id,
+                int level)
+{
+    int pending = epicsMessageQueuePending(id);
+    if (pending >= 0)
+        printf ("Message queue %lx -- Pending: %d\n", (unsigned long)id, pending);
+}

modules/libcom/src/osi/os/RTEMS-kernel/osdMessageQueue.h

@@ -0,0 +1,29 @@
+/*************************************************************************\
+* 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. 
+\*************************************************************************/
+/*
+ *      Author  W. Eric Norum
+ *              norume@aps.anl.gov
+ *              630 252 4793
+ */
+
+/*
+ * Very thin shims around RTEMS routines
+ */
+#include <rtems.h>
+
+struct epicsMessageQueueOSD {
+    rtems_id     id;
+    unsigned int maxSize;
+    void        *localBuf;
+
+};
+#define epicsMessageQueueDestroy(q) (rtems_message_queue_delete((q)->id))
+
+#define epicsMessageQueueTrySend(q,m,l) (rtems_message_queue_send((q)->id, (m), (l)) == RTEMS_SUCCESSFUL ? 0 : -1)

modules/libcom/src/osi/os/RTEMS-posix/osdMessageQueue.c

@@ -0,0 +1,160 @@
+/*************************************************************************\
+* 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. 
+\*************************************************************************/
+/*
+ *      Author  W. Eric Norum
+ *              norume@aps.anl.gov
+ *              630 252 4793
+ */
+
+/*
+ * 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>
+
+LIBCOM_API epicsMessageQueueId epicsStdCall
+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_%01d", 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) {
+        fprintf (stderr, "Can't create message queue: %s\n", strerror (errno));
+        return NULL;
+    }
+    return id;
+}
+
+LIBCOM_API void epicsStdCall epicsMessageQueueDestroy(
+    epicsMessageQueueId id)
+{
+  int rv;
+  rv = mq_close(id->id);
+  if( rv ) { 
+    fprintf(stderr, "epicsMessageQueueDestroy mq_close failed: %s\n",
+                         strerror(rv));
+  }
+  rv = mq_unlink(id->name);
+  if( rv ) { 
+    fprintf(stderr,"epicsMessageQueueDestroy mq_unlink %s failed: %s\n",
+                         id->name, strerror(rv));
+  }
+  free(id);
+}
+
+
+LIBCOM_API int epicsStdCall 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);
+}
+
+LIBCOM_API int epicsStdCall 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);
+}
+
+LIBCOM_API int epicsStdCall 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);
+}
+
+LIBCOM_API int epicsStdCall 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);
+}
+
+LIBCOM_API int epicsStdCall epicsMessageQueuePending(
+            epicsMessageQueueId id)
+{
+  int rv;
+  struct mq_attr the_attr;
+
+  rv = mq_getattr(id->id, &the_attr);
+  if (rv) {
+    fprintf(stderr, "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;
+}
+LIBCOM_API void epicsStdCall epicsMessageQueueShow(
+            epicsMessageQueueId id,
+                int level)
+{
+  int rv;
+  struct mq_attr the_attr;
+
+  rv = mq_getattr(id->id, &the_attr);
+  if (rv) {
+    fprintf(stderr, "Epics Message queue %x (%s) get attr failed: %s\n",
+                         (unsigned int)id->id, id->name, 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");
+}

modules/libcom/src/osi/os/RTEMS-posix/osdMessageQueue.h

@@ -0,0 +1,29 @@
+/*************************************************************************\
+* 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. 
+\*************************************************************************/
+/*
+ *      Author  W. Eric Norum
+ *              norume@aps.anl.gov
+ *              630 252 4793
+ */
+
+/*
+ * Very thin shims around RTEMS routines
+ */
+#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))

modules/libcom/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"

modules/libcom/src/osi/os/RTEMS-posix/osdPoolStatus.c

@@ -0,0 +1,27 @@
+/*************************************************************************\
+* 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. 
+\*************************************************************************/
+#include <rtems.h>
+#include <rtems/malloc.h>
+#include <rtems/score/heap.h>
+#define epicsExportSharedSymbols
+#include "osiPoolStatus.h"
+
+/*
+ * osiSufficentSpaceInPool ()
+ */
+LIBCOM_API int epicsStdCall 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));
+}

modules/libcom/src/osi/os/RTEMS-posix/osdSock.h

@@ -0,0 +1,81 @@
+/*************************************************************************\
+* 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 is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution.
+\*************************************************************************/
+
+/*
+ * Linux specific socket include
+ */
+
+#ifndef osdSockH
+#define osdSockH
+
+#include <sys/errno.h>
+
+#include <sys/types.h>
+#include <sys/param.h> /* for MAXHOSTNAMELEN */
+#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 <unistd.h> /* close() and others */
+
+
+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 int osiSockOptMcastLoop_t;
+typedef int osiSockOptMcastTTL_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 ESHUTDOWN
+#define SOCK_ENOTSOCK ENOTSOCK
+#define SOCK_EBADF EBADF
+
+#ifndef SHUT_RD
+#   define SHUT_RD 0
+#endif
+
+#ifndef SHUT_WR
+#   define SHUT_WR 1
+#endif
+
+#ifndef SHUT_RDWR
+#   define SHUT_RDWR 2
+#endif
+
+#define ifreq_size(pifreq) (sizeof(pifreq->ifr_name))
+
+#ifndef IPPORT_USERRESERVED
+#define IPPORT_USERRESERVED 5000
+#endif
+
+#endif /*osdSockH*/