ringbuf.h

Go to the documentation of this file.

/*
 * (c) 2010 Björn Döbel <doebel@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU Lesser General Public License 2.1.
 * Please see the COPYING-LGPL-2.1 file for details.
 */
 
#pragma once
 
#include <l4/shmc/shmc.h>
#include <l4/util/assert.h>
#include <l4/sys/thread.h>
 
__BEGIN_DECLS
 
/*
 * Turn on ringbuf poisoning. This will add magic values to the ringbuf
 * header as well as each packet header and check that these values are
 * valid all the time.
 */
#define L4SHMC_RINGBUF_POISONING 1
 
typedef struct
{
  volatile l4_uint32_t lock;
  unsigned data_size;
#if L4SHMC_RINGBUF_POISONING
  char     magic1;
#endif
  unsigned next_read;    
  unsigned next_write;   
#if L4SHMC_RINGBUF_POISONING
  char     magic2;
#endif
  unsigned bytes_filled; 
  unsigned sender_waits; 
#if L4SHMC_RINGBUF_POISONING
  char     magic3;
#endif
  char data[];           
} l4shmc_ringbuf_head_t;
 
 
typedef struct
{
  l4shmc_area_t   *_area;         
  l4_cap_idx_t     _owner;        
  l4shmc_chunk_t   _chunk;        
  unsigned         _size;         
  char            *_chunkname;    
  char            *_signame;      
  l4shmc_ringbuf_head_t  *_addr;         
  l4shmc_signal_t  _signal_full;  
  l4shmc_signal_t  _signal_empty; 
} l4shmc_ringbuf_t;
 
 
#define L4SHMC_RINGBUF_HEAD(ringbuf)       ((l4shmc_ringbuf_head_t*)((ringbuf)->_addr))
 
 
#define L4SHMC_RINGBUF_DATA(ringbuf)       (L4SHMC_RINGBUF_HEAD(ringbuf)->data)
 
 
#define L4SHMC_RINGBUF_DATA_SIZE(ringbuf)  ((ringbuf)->_size - sizeof(l4shmc_ringbuf_head_t))
 
enum lock_content
{
  lock_cont_min = 4,
  locked        = 5,
  unlocked      = 6,
  lock_cont_max = 7,
};
 
static L4_CV inline void l4shmc_rb_lock(l4shmc_ringbuf_head_t *head)
{
  ASSERT_NOT_NULL(head);
  ASSERT_ASSERT(head->lock > lock_cont_min);
  ASSERT_ASSERT(head->lock < lock_cont_max);
 
  while (!l4util_cmpxchg32(&head->lock, unlocked, locked))
    l4_thread_yield();
}
 
 
static L4_CV inline void l4shmc_rb_unlock(l4shmc_ringbuf_head_t *head)
{
  ASSERT_NOT_NULL(head);
  ASSERT_ASSERT(head->lock > lock_cont_min);
  ASSERT_ASSERT(head->lock < lock_cont_max);
 
  head->lock = unlocked;
}
 
/******************
 * Initialization *
 ******************/
 
L4_CV int  l4shmc_rb_init_buffer(l4shmc_ringbuf_t *buf, l4shmc_area_t *area,
                                 char const *chunk_name,
                                 char const *signal_name, unsigned size);
 
L4_CV void l4shmc_rb_deinit_buffer(l4shmc_ringbuf_t *buf);
 
 
 
/***************************
 *    RINGBUF SENDER       *
 ***************************/
 
L4_CV int l4shmc_rb_attach_sender(l4shmc_ringbuf_t *buf, char const *signal_name,
                                  l4_cap_idx_t owner);
 
 
L4_CV char *l4shmc_rb_sender_alloc_packet(l4shmc_ringbuf_head_t *head,
                                          unsigned psize);
 
 
L4_CV void l4shmc_rb_sender_put_data(l4shmc_ringbuf_t *buf, char *addr,
                                     char *data, unsigned dsize);
 
 
L4_CV int  l4shmc_rb_sender_next_copy_in(l4shmc_ringbuf_t *buf, char *data,
                                          unsigned size, int block_if_necessary);
 
 
L4_CV void l4shmc_rb_sender_commit_packet(l4shmc_ringbuf_t *buf);
 
 
/***************************
 *    RINGBUF RECEIVER     *
 ***************************/
 
L4_CV int  l4shmc_rb_init_receiver(l4shmc_ringbuf_t *buf, l4shmc_area_t *area,
                                    char const *chunk_name,
                                    char const *signal_name);
 
 
L4_CV void l4shmc_rb_attach_receiver(l4shmc_ringbuf_t *buf, l4_cap_idx_t owner);
 
 
L4_CV int l4shmc_rb_receiver_wait_for_data(l4shmc_ringbuf_t *buf, int blocking);
 
 
L4_CV int  l4shmc_rb_receiver_copy_out(l4shmc_ringbuf_head_t *head, char *target,
                                        unsigned *tsize);
 
 
L4_CV void l4shmc_rb_receiver_notify_done(l4shmc_ringbuf_t *buf);
 
 
L4_CV int l4shmc_rb_receiver_read_next_size(l4shmc_ringbuf_head_t *head);
 
__END_DECLS