buffer.c File Reference

#include "libisofs.h"
#include "buffer.h"
#include "ecma119.h"
#include <pthread.h>
#include <string.h>

Include dependency graph for buffer.c:

Go to the source code of this file.

Data Structures
struct	iso_ring_buffer

Macros
#define	LIBISOFS_WITHOUT_LIBBURN   yes

Functions
int	iso_ring_buffer_new (size_t size, IsoRingBuffer **rbuf)
	Create a new buffer. More...
void	iso_ring_buffer_free (IsoRingBuffer *buf)
	Free a given buffer. More...
int	iso_ring_buffer_write (IsoRingBuffer *buf, uint8_t *data, size_t count)
	Write count bytes into buffer. More...
int	iso_ring_buffer_read (IsoRingBuffer *buf, uint8_t *dest, size_t count)
	Read count bytes from the buffer into dest. More...
void	iso_ring_buffer_writer_close (IsoRingBuffer *buf, int error)
	Close the buffer (to be called by the writer). More...
void	iso_ring_buffer_reader_close (IsoRingBuffer *buf, int error)
	Close the buffer (to be called by the reader). More...
unsigned int	iso_ring_buffer_get_times_full (IsoRingBuffer *buf)
	Get the times the buffer was full. More...
unsigned int	iso_ring_buffer_get_times_empty (IsoRingBuffer *buf)
	Get the times the buffer was empty. More...
int	iso_ring_buffer_get_buf_status (IsoRingBuffer *buf, size_t *size, size_t *free_bytes)
	Internal via buffer.h. More...
int	iso_ring_buffer_get_status (struct burn_source *b, size_t *size, size_t *free_bytes)
	API via libisofs.h. More...

Macro Definition Documentation

LIBISOFS_WITHOUT_LIBBURN

#define LIBISOFS_WITHOUT_LIBBURN   yes

Definition at line 27 of file buffer.c.

Function Documentation

iso_ring_buffer_free()

void iso_ring_buffer_free

(

IsoRingBuffer *

buf

)

Free a given buffer.

Definition at line 124 of file buffer.c.

{
    if (buf == NULL) {
        return;
    }
    free(buf->buf);
    pthread_mutex_destroy(&buf->mutex);
    pthread_cond_destroy(&buf->empty);
    pthread_cond_destroy(&buf->full);
    free(buf);
}

References iso_ring_buffer::buf, iso_ring_buffer::empty, iso_ring_buffer::full, and iso_ring_buffer::mutex.

Referenced by ecma119_image_free().

iso_ring_buffer_get_buf_status()

int iso_ring_buffer_get_buf_status	(	IsoRingBuffer *	buf,
		size_t *	size,
		size_t *	free_bytes
	)

Internal via buffer.h.

Backend of API call iso_ring_buffer_get_status()

Get the status of a ring buffer.

Parameters

buf	The ring buffer object to inquire
size	Will be filled with the total size of the buffer, in bytes
free_bytes	Will be filled with the bytes currently available in buffer

Returns

< 0 error, > 0 state: 1="active" : input and consumption are active 2="ending" : input has ended without error 3="failing" : input had error and ended, 5="abandoned" : consumption has ended prematurely 6="ended" : consumption has ended without input error 7="aborted" : consumption has ended after input error

Definition at line 315 of file buffer.c.

{
    int ret;
 
    if (buf == NULL) {
        return ISO_NULL_POINTER;
    }
 
    /* get mutex */
    pthread_mutex_lock(&buf->mutex);
    if (size) {
        *size = buf->cap;
    }
    if (free_bytes) {
        *free_bytes = buf->cap - buf->size;
    }
 
    ret = (buf->rend ? 4 : 0) + (buf->wend + 1);
 
    pthread_mutex_unlock(&buf->mutex);
    return ret;
}

References iso_ring_buffer::cap, ISO_NULL_POINTER, iso_ring_buffer::mutex, iso_ring_buffer::rend, iso_ring_buffer::size, and iso_ring_buffer::wend.

Referenced by iso_ring_buffer_get_status(), and write_head_part1().

iso_ring_buffer_get_status()

int iso_ring_buffer_get_status	(	struct burn_source *	b,
		size_t *	size,
		size_t *	free_bytes
	)

API via libisofs.h.

Get the status of the buffer used by a burn_source.

Get the status of the buffer used by a burn_source.

Parameters

b	A burn_source previously obtained with iso_image_create_burn_source().
size	Will be filled with the total size of the buffer, in bytes
free_bytes	Will be filled with the bytes currently available in buffer

Returns

< 0 error, > 0 state: 1="active" : input and consumption are active 2="ending" : input has ended without error 3="failing" : input had error and ended, 5="abandoned" : consumption has ended prematurely 6="ended" : consumption has ended without input error 7="aborted" : consumption has ended after input error

Definition at line 359 of file buffer.c.

{
    int ret;
    IsoRingBuffer *buf;
    if (b == NULL) {
        return ISO_NULL_POINTER;
    }
    buf = ((Ecma119Image*)(b->data))->buffer;
    ret = iso_ring_buffer_get_buf_status(buf, size, free_bytes);
    return ret;
}

References ISO_NULL_POINTER, and iso_ring_buffer_get_buf_status().

Referenced by bs_cancel(), and bs_free_data().

iso_ring_buffer_get_times_empty()

unsigned int iso_ring_buffer_get_times_empty

(

IsoRingBuffer *

buf

)

Get the times the buffer was empty.

Definition at line 290 of file buffer.c.

{
    return buf->times_empty;
}

References iso_ring_buffer::times_empty.

Referenced by bs_free_data().

iso_ring_buffer_get_times_full()

unsigned int iso_ring_buffer_get_times_full

(

IsoRingBuffer *

buf

)

Get the times the buffer was full.

Definition at line 282 of file buffer.c.

{
    return buf->times_full;
}

References iso_ring_buffer::times_full.

Referenced by bs_free_data().

iso_ring_buffer_new()

int iso_ring_buffer_new	(	size_t	size,
		IsoRingBuffer **	rbuf
	)

Create a new buffer.

The created buffer should be freed with iso_ring_buffer_free()

Parameters

size	Number of blocks in buffer. You should supply a number >= 32, otherwise size will be ignored and 32 will be used by default, which leads to a 64 KiB buffer.

Returns

1 success, < 0 error

Definition at line 86 of file buffer.c.

{
    IsoRingBuffer *buffer;
 
    if (rbuf == NULL) {
        return ISO_NULL_POINTER;
    }
 
    buffer = malloc(sizeof(IsoRingBuffer));
    if (buffer == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    buffer->cap = (size > 32 ? size : 32) * BLOCK_SIZE;
    buffer->buf = malloc(buffer->cap);
    if (buffer->buf == NULL) {
        free(buffer);
        return ISO_OUT_OF_MEM;
    }
 
    buffer->size = 0;
    buffer->wpos = 0;
    buffer->rpos = 0;
 
    buffer->times_full = 0;
    buffer->times_empty = 0;
 
    buffer->rend = buffer->wend = 0;
 
    /* init mutex and waiting queues */
    pthread_mutex_init(&buffer->mutex, NULL);
    pthread_cond_init(&buffer->empty, NULL);
    pthread_cond_init(&buffer->full, NULL);
 
    *rbuf = buffer;
    return ISO_SUCCESS;
}

References BLOCK_SIZE, iso_ring_buffer::buf, iso_ring_buffer::cap, iso_ring_buffer::empty, iso_ring_buffer::full, ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_SUCCESS, iso_ring_buffer::mutex, iso_ring_buffer::rend, iso_ring_buffer::rpos, iso_ring_buffer::size, iso_ring_buffer::times_empty, iso_ring_buffer::times_full, iso_ring_buffer::wend, and iso_ring_buffer::wpos.

Referenced by ecma119_image_new().

iso_ring_buffer_read()

int iso_ring_buffer_read	(	IsoRingBuffer *	buf,
		uint8_t *	dest,
		size_t	count
	)

Read count bytes from the buffer into dest.

It blocks until the desired bytes has been read. If the writer finishes before outputting enough bytes, 0 (EOF) is returned, the number of bytes already read remains unknown.

Returns

1 success, 0 EOF, < 0 error

Definition at line 206 of file buffer.c.

{
    size_t len;
    size_t bytes_read = 0;
 
    if (buf == NULL || dest == NULL) {
        return ISO_NULL_POINTER;
    }
 
    while (bytes_read < count) {
        pthread_mutex_lock(&buf->mutex);
 
        while (buf->size == 0) {
            /*
             * Note. There's only a reader, so we have no race conditions.
             * Thus, the while(buf->size == 0) is used here just to ensure
             * a reader detects the EOF properly if the writer has been
             * canceled while the reader was waiting
             */
 
            if (buf->wend) {
                /* the writer procces has been finished */
                pthread_mutex_unlock(&buf->mutex);
                return 0; /* EOF */
            }
            buf->times_empty++;
            /* wait until data available */
            pthread_cond_wait(&buf->empty, &buf->mutex);
        }
 
        len = MIN(count - bytes_read, buf->size);
        if (buf->rpos + len > buf->cap) {
            len = buf->cap - buf->rpos;
        }
        memcpy(dest + bytes_read, buf->buf + buf->rpos, len);
        buf->rpos = (buf->rpos + len) % (buf->cap);
        bytes_read += len;
        buf->size -= len;
 
        /* wake up the writer */
        pthread_cond_signal(&buf->full);
        pthread_mutex_unlock(&buf->mutex);
    }
    return ISO_SUCCESS;
}

References iso_ring_buffer::buf, iso_ring_buffer::cap, iso_ring_buffer::empty, iso_ring_buffer::full, ISO_NULL_POINTER, ISO_SUCCESS, MIN, iso_ring_buffer::mutex, iso_ring_buffer::rpos, iso_ring_buffer::size, iso_ring_buffer::times_empty, and iso_ring_buffer::wend.

Referenced by bs_read(), and ecma119_image_new().

iso_ring_buffer_reader_close()

void iso_ring_buffer_reader_close	(	IsoRingBuffer *	buf,
		int	error
	)

Close the buffer (to be called by the reader).

If for any reason you don't want to read more data, you need to call this to let the writer thread finish.

Parameters

error

Reader has finished prematurely due to an error

Definition at line 262 of file buffer.c.

{
    pthread_mutex_lock(&buf->mutex);
 
    if (buf->rend) {
        /* reader already closed */
        pthread_mutex_unlock(&buf->mutex);
        return;
    }
 
    buf->rend = error ? 2 : 1;
 
    /* ensure no writer is waiting */
    pthread_cond_signal(&buf->full);
    pthread_mutex_unlock(&buf->mutex);
}

References iso_ring_buffer::full, iso_ring_buffer::mutex, and iso_ring_buffer::rend.

Referenced by bs_cancel(), and bs_free_data().

iso_ring_buffer_write()

int iso_ring_buffer_write	(	IsoRingBuffer *	buf,
		uint8_t *	data,
		size_t	count
	)

Write count bytes into buffer.

It blocks until all bytes where written or reader close the buffer.

Parameters

buf	the buffer
data	pointer to a memory region of at least coun bytes, from which data will be read.
Number	of bytes to write

Returns

1 success, 0 read finished, < 0 error

Definition at line 150 of file buffer.c.

{
    size_t len;
    size_t bytes_write = 0;
 
    if (buf == NULL || data == NULL) {
        return ISO_NULL_POINTER;
    }
 
    while (bytes_write < count) {
 
        pthread_mutex_lock(&buf->mutex);
 
        while (buf->size == buf->cap) {
 
            /*
             * Note. There's only a writer, so we have no race conditions.
             * Thus, the while(buf->size == buf->cap) is used here
             * only to properly detect the reader has been cancelled
             */
 
            if (buf->rend) {
                /* the read procces has been finished */
                pthread_mutex_unlock(&buf->mutex);
                return 0;
            }
            buf->times_full++;
            /* wait until space available */
            pthread_cond_wait(&buf->full, &buf->mutex);
        }
 
        len = MIN(count - bytes_write, buf->cap - buf->size);
        if (buf->wpos + len > buf->cap) {
            len = buf->cap - buf->wpos;
        }
        memcpy(buf->buf + buf->wpos, data + bytes_write, len);
        buf->wpos = (buf->wpos + len) % (buf->cap);
        bytes_write += len;
        buf->size += len;
 
        /* wake up reader */
        pthread_cond_signal(&buf->empty);
        pthread_mutex_unlock(&buf->mutex);
    }
    return ISO_SUCCESS;
}

References iso_ring_buffer::buf, iso_ring_buffer::cap, iso_ring_buffer::empty, iso_ring_buffer::full, ISO_NULL_POINTER, ISO_SUCCESS, MIN, iso_ring_buffer::mutex, iso_ring_buffer::rend, iso_ring_buffer::size, iso_ring_buffer::times_full, and iso_ring_buffer::wpos.

Referenced by iso_write().

iso_ring_buffer_writer_close()

void iso_ring_buffer_writer_close	(	IsoRingBuffer *	buf,
		int	error
	)

Close the buffer (to be called by the writer).

You have to explicitly close the buffer when you don't have more data to write, otherwise reader will be waiting forever.

Parameters

error

Writer has finished prematurely due to an error

Definition at line 252 of file buffer.c.

{
    pthread_mutex_lock(&buf->mutex);
    buf->wend = error ? 2 : 1;
 
    /* ensure no reader is waiting */
    pthread_cond_signal(&buf->empty);
    pthread_mutex_unlock(&buf->mutex);
}

References iso_ring_buffer::empty, iso_ring_buffer::mutex, and iso_ring_buffer::wend.

Referenced by write_function().