rtems-rfs-buffer.h

Go to the documentation of this file.

/*
 *  COPYRIGHT (c) 2010 Chris Johns <chrisj@rtems.org>
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.org/license/LICENSE.
 */


#if !defined (_RTEMS_RFS_BUFFER_H_)
#define _RTEMS_RFS_BUFFER_H_

#include <errno.h>

#include <rtems/rfs/rtems-rfs-file-system-fwd.h>
#include <rtems/rfs/rtems-rfs-trace.h>

#if defined (__rtems__)
#define RTEMS_RFS_USE_LIBBLOCK 1
#endif

#if RTEMS_RFS_USE_LIBBLOCK
#include <rtems/bdbuf.h>
#include <rtems/error.h>

typedef rtems_blkdev_bnum  rtems_rfs_buffer_block;
typedef rtems_bdbuf_buffer rtems_rfs_buffer;
#define rtems_rfs_buffer_io_request rtems_rfs_buffer_bdbuf_request
#define rtems_rfs_buffer_io_release rtems_rfs_buffer_bdbuf_release

int rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system* fs,
                                    rtems_rfs_buffer_block block,
                                    bool                   read,
                                    rtems_rfs_buffer**     buffer);
int rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* handle,
                                    bool              modified);
#else /* Device I/O */
typedef uint32_t rtems_rfs_buffer_block;
typedef struct _rtems_rfs_buffer
{
  rtems_chain_node       link;
  rtems_rfs_buffer_block user;
  void*                  buffer;
  size_t                 size;
  uint32_t               references;
} rtems_rfs_buffer;
#define rtems_rfs_buffer_io_request rtems_rfs_buffer_deviceio_request
#define rtems_rfs_buffer_io_release rtems_rfs_buffer_deviceio_release

int rtems_rfs_buffer_deviceio_request (rtems_rfs_file_system* fs,
                                       rtems_rfs_buffer_block block,
                                       bool                   read,
                                       rtems_rfs_buffer*      buffer);
int rtems_rfs_buffer_deviceio_release (rtems_rfs_buffer* handle,
                                       bool              modified);
#endif

typedef struct rtems_rfs_buffer_handle_t
{
  bool dirty;

  rtems_rfs_buffer_block bnum;

  rtems_rfs_buffer* buffer;

} rtems_rfs_buffer_handle;

#define rtems_rfs_buffer_link(_h) (&(_h)->buffer->link)

#define rtems_rfs_buffer_data(_h) ((void*)((_h)->buffer->buffer))

#define rtems_rfs_buffer_size(_h) ((_h)->buffer->size)

#define rtems_rfs_buffer_bnum(_h) ((_h)->bnum)

#define rtems_rfs_buffer_dirty(_h) ((_h)->dirty)

#define rtems_rfs_buffer_handle_has_block(_h) ((_h)->buffer ? true : false)

#define rtems_rfs_buffer_mark_dirty(_h) ((_h)->dirty = true)

#define rtems_rfs_buffer_refs(_h) ((_h)->buffer->references)

#define rtems_rfs_buffer_refs_up(_h) ((_h)->buffer->references += 1)

#define rtems_rfs_buffer_refs_down(_h) ((_h)->buffer->references -= 1)

int rtems_rfs_buffer_handle_request (rtems_rfs_file_system*   fs,
                                     rtems_rfs_buffer_handle* handle,
                                     rtems_rfs_buffer_block   block,
                                     bool                     read);

int rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,
                                     rtems_rfs_buffer_handle* handle);

static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,
                              rtems_rfs_buffer_handle* handle)
{
  handle->dirty = false;
  handle->bnum  = 0;
  handle->buffer = NULL;
  return 0;
}

static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system*   fs,
                               rtems_rfs_buffer_handle* handle)
{
  rtems_rfs_buffer_handle_release (fs, handle);
  handle->dirty = false;
  handle->bnum  = 0;
  handle->buffer = NULL;
  return 0;
}

int rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs);

int rtems_rfs_buffer_close (rtems_rfs_file_system* fs);

int rtems_rfs_buffer_sync (rtems_rfs_file_system* fs);

int rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, uint32_t size);

int rtems_rfs_buffers_release (rtems_rfs_file_system* fs);

#endif