---

rtlnml.c

Go to the documentation of this file.

struct RTLNML_HEADER
{
  long message_type;
  unsigned long message_size;
  long first_message_count;
  long second_message_count;
};

struct RTLNML
{
  struct RTLNML_HEADER *header;
  void *mbuff_address;
  void *direct_data_pointer;
  void *local_pointer;
  int rtlnml_allocated_local_pointer;
  unsigned long max_message_size;
  int last_id_read;
#if defined(rtai) || defined(linux_rtai)
  int key;
#endif
};

typedef struct RTLNML *rtlnml_t;

#if defined(rtai) || defined(linux_rtai)
typedef rtlnml_t rtainml_t;

#ifdef rtai
#include <linux/module.h>
#else
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <unistd.h>
#endif

#include "rtai_shm.h"
#endif

#define RTLNML_TYPEDEFED
#ifdef MODULE
#undef MODULE
#endif


#include "rtlnml.h"

#if !defined(rtlinux) && !defined(rtai)
#include <stdlib.h>
#endif

// On a Debian 2.2/ glibc 2.1.3, linux kernel 2.4.1, rtl 3.0 
// insane compile errors occur if linux/string.h is included after string.h
#ifdef  NEED_LINUX_STRING_H
#include <linux/string.h>
/* But then again, two fatal parsing errors crop up if linux/string.h is
   included on a RH7.1 2.4.9-rtai system.
   Also causes multiple defines of strnlen on BDI 2.10 for nonrealtime compile.)
   (aproximately RedHat 6.x, glibc 2.1.1, rtlinux 3.0)
*/
#endif

#include <string.h>

#if defined(rtlinux) || defined(rtai)
extern void *kmalloc (unsigned long, int);
extern void kfree (const void *);
#endif


//
// This insanity is here because mbuff.h puts C functions in the header file.
// We need the function but if we end up exporting it it will cause multiple
// definition linker errors. Therefore we use this nonsense plus some extra
// gcc flags to get rid of those functions.
//
// added by terrylr on 15 october 2000.
// changed the ifdef to an if defined conditional.
// if either rtlinux_2_0 or rtlinux_2_3 is defined
// inline will be redefined to be static.
// this is only necessary for version rtlinux-2.0 & rtlinux-2.3.
// version rtlinux-2.2 defines certain functions declared in
// mbuff.h to be static inline.
//
#if defined(rtlinux) || defined(HAVE_RTL)
#include <linux/types.h>
#include <linux/fs.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifndef rtlinux_2_2
#define inline static inline
#endif
#include "mbuff.h"
#ifndef rtlinux_2_2
#undef inline
#endif
#endif

/* All applications should call this before any other rtlnml functions. */
/* In rtlinux, call this only from init_module, never from an RT task
   function. */
void
rtlnml_init (void)
{
}

static inline void *
rtlnml_malloc (unsigned long sz)
{
#if defined(rtlinux) || defined(rtai)
  return ((void *) kmalloc (sz, 1));
#else
  return malloc (sz);
#endif
}

static inline void
rtlnml_free (void *p)
{
#if defined(rtlinux) || defined(rtai)
  kfree (p);
#else
  free (p);
#endif
}



/* This fuction is used to create each channel. */
/* In rtlinux, call this only from init_module, never from an RT task
   function. */
#if !defined(rtai) && !defined(linux_rtai)
rtlnml_t
rtlnml_open (const char *name,  /* buffer name */
             const char *processname,   /* process name (not used) */
             const char *filename,      /* configuration file (not used) */
             unsigned long size,        /* Maximum size of message for buffer, (actual buffer is slightly larger). */
             int master)
#else
rtainml_t
rtainml_open (const char *name, /* buffer name */
              const char *processname,  /* process name (not used) */
              const char *filename,     /* configuration file (not used) */
              unsigned long size,       /* Maximum size of message for buffer, (actual buffer is slightly larger). */
              int master, int key)
#endif
{
  int i;
  struct RTLNML *r = NULL;

  r = (struct RTLNML *) rtlnml_malloc (sizeof (struct RTLNML));
  if (NULL == r)
    {
      return NULL;
    }
  r->header = NULL;
  r->mbuff_address = NULL;
  r->direct_data_pointer = NULL;
  r->local_pointer = NULL;
  r->rtlnml_allocated_local_pointer = 0;
  r->max_message_size = 0;
  r->last_id_read = 0;

#ifdef rtai
  r->mbuff_address = rtai_kmalloc (key, size + 16);
  r->key = key;
#else
#ifdef linux_rtai
  r->mbuff_address = rtai_malloc (key, size + 16);
  r->key = key;
#else
  r->mbuff_address = mbuff_alloc (name, size + 16);
#endif
#endif
  if (NULL == r->mbuff_address)
    {
      rtlnml_free (r);
      return NULL;
    }

  if (master)
    {
      for (i = 0; i < size + 16; i++)
        {
          ((char *) (r->mbuff_address))[i] = 0;
        }
    }
  r->local_pointer = rtlnml_malloc (size);
  r->rtlnml_allocated_local_pointer = 1;
  r->direct_data_pointer = (void *) (((char *) r->mbuff_address) + 16);
  r->header = (struct RTLNML_HEADER *) r->mbuff_address;
  r->max_message_size = size;
  return r;
}


/* These functions get and release
   a direct pointer to the shared memory area.
   If a read occurs while the
   writer has direct access to the shared memory a split-buffer error will
   occur when either  rtlnml_get_direct_pointer_for_read,
   rtlnml_release_direct_pointer_for_read or rtlnml_read will return
   RTLNML_SPLIT_READ
   So the pointer should be released as soon as possible.*/
int
rtlnml_get_direct_pointer_for_read (rtlnml_t r, void **p)
{
  if (r->last_id_read == r->header->first_message_count)
    {
      return RTLNML_READ_OLD;
    }
  if (r->header->first_message_count != r->header->second_message_count)
    {
      return RTLNML_SPLIT_READ_ERROR;
    }
  r->last_id_read = r->header->first_message_count;
  *p = r->direct_data_pointer;
  return r->header->message_type;
}

int
rtlnml_release_direct_pointer_for_read (rtlnml_t r, void **p)
{
  *p = NULL;
  if (r->header->second_message_count != r->last_id_read)
    {
      return RTLNML_SPLIT_READ_ERROR;
    }
  return r->header->message_type;
}

int
rtlnml_get_direct_pointer_for_write (rtlnml_t r, void **p)
{
  r->header->first_message_count++;
  *p = r->direct_data_pointer;
  return (0);
}

int
rtlnml_release_direct_pointer_for_write (rtlnml_t r, void **p, long msg_type,
                                         unsigned long msg_size)
{
  *p = NULL;
  r->header->message_type = msg_type;
  r->header->message_size = msg_size;
  r->header->second_message_count = r->header->first_message_count;
  if (msg_size <= r->max_message_size && msg_size > 0)
    {
      return (-1);
    }
  return (0);
}

  /* Reads from the buffer, possibly copying the contents to the location
     that can be obtained with rtlnml_get_local_pointer. This is
     safer and more flexible than using direct pointers but possibly
     slower. */
long
rtlnml_read (rtlnml_t r)
{
  long orig_last_id_read = r->last_id_read;
  long msg_type;
  if (r->last_id_read == r->header->first_message_count)
    {
      return RTLNML_READ_OLD;
    }
  if (r->header->first_message_count != r->header->second_message_count)
    {
      return RTLNML_SPLIT_READ_ERROR;
    }
  if (r->header->message_size <= 0
      || r->header->message_size > r->max_message_size)
    {
      return RTLNML_READ_ERROR;
    }
  r->last_id_read = r->header->first_message_count;
  msg_type = r->header->message_type;
#ifdef USE_BCOPY
  bcopy (r->direct_data_pointer, r->local_pointer, r->header->message_size);
#else
  memcpy (r->local_pointer, r->direct_data_pointer, r->header->message_size);
#endif /* ] */
  if (r->last_id_read != r->header->second_message_count)
    {
      r->last_id_read = orig_last_id_read;
      return RTLNML_SPLIT_READ_ERROR;
    }
  return msg_type;
}

  /* Writes to the buffer. This may be
     safer and more flexible than using direct pointers but possibly
     slower. */
long
rtlnml_write (rtlnml_t r, void *data,   /* address of data to be copied into nml buffer. */
              long msg_type,    /* NML message type. */
              unsigned long msg_size)   /* size of message */
{
  if (msg_size <= 0 || msg_size > r->max_message_size)
    {
      return RTLNML_WRITE_ERROR;
    }
  r->header->first_message_count++;
#ifdef USE_BCOPY
  bcopy (data, r->direct_data_pointer, msg_size);
#else
  memcpy (r->direct_data_pointer, data, msg_size);
#endif
  r->header->message_size = msg_size;
  r->header->message_type = msg_type;
  r->header->second_message_count = r->header->first_message_count;
  return (RTLNML_WRITE_OK);
}

  /* This function should be called after a successful rtlnml_read to
     get a pointer to a local copy of the message. */
void *
rtlnml_get_local_pointer (rtlnml_t r)
{
  return r->local_pointer;
}

/* Use only if you want rtlnml_read to copy data to a special location.*/
extern void
rtlnml_set_local_pointer (rtlnml_t r, void *p)
{
  if (NULL != r->local_pointer && r->rtlnml_allocated_local_pointer)
    {
      rtlnml_free (r->local_pointer);
    }
  r->rtlnml_allocated_local_pointer = 0;
  r->local_pointer = p;
}

  /* Close each channel. */
void
rtlnml_close (rtlnml_t r, const char *bufname)
{
  if (NULL != r)
    {
      if (NULL != r->mbuff_address)
        {
#ifdef rtai
          rtai_kfree (r->key);
#else
#ifdef linux_rtai
          rtai_free (r->key, r->mbuff_address);
#else
          mbuff_free (bufname, r->mbuff_address);
#endif
#endif
          r->mbuff_address = NULL;
        }
      if (NULL != r->local_pointer && r->rtlnml_allocated_local_pointer)
        {
          rtlnml_free (r->local_pointer);
          r->local_pointer = NULL;
        }
      rtlnml_free (r);
    }
}

/* This function should be called after all other rtlnml functions. */
/* In rtlinux call this only from cleanup_module, never from an RT task function. */
void
rtlnml_exit ()
{
}

---