ndmpd/tlm/tlm_buffers.c

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  - Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *  - Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 *  - Neither the name of The Storage Networking Industry Association (SNIA)
 *    nor the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/errno.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <synch.h>
#include <tlm_buffers.h>
#include <tlm.h>
#include "tlm_proto.h"


/*
 * tlm_allocate_buffers
 *
 * build a set of buffers
 */
tlm_buffers_t *
tlm_allocate_buffers(boolean_t write, long xfer_size)
{
    tlm_buffers_t *buffers = ndmp_malloc(sizeof (tlm_buffers_t));
    int buf;

    if (buffers == 0)
        return (0);

    for (buf = 0; buf < TLM_TAPE_BUFFERS; buf++) {
        buffers->tbs_buffer[buf].tb_buffer_data =
            ndmp_malloc(xfer_size);
        if (buffers->tbs_buffer[buf].tb_buffer_data == 0) {
            int i;

            /* Memory allocation failed. Give everything back */
            for (i = 0; i < buf; i++)
                free(buffers->tbs_buffer[i].tb_buffer_data);

            free(buffers);
            return (0);
        } else {
            buffers->tbs_buffer[buf].tb_buffer_size = (write)
                ? xfer_size : 0;
            buffers->tbs_buffer[buf].tb_full = FALSE;
            buffers->tbs_buffer[buf].tb_eof = FALSE;
            buffers->tbs_buffer[buf].tb_eot = FALSE;
            buffers->tbs_buffer[buf].tb_errno = 0;
            buffers->tbs_buffer[buf].tb_buffer_spot = 0;
        }

    }

    (void) mutex_init(&buffers->tbs_mtx, 0, NULL);
    (void) cond_init(&buffers->tbs_in_cv, 0, NULL);
    (void) cond_init(&buffers->tbs_out_cv, 0, NULL);

    buffers->tbs_data_transfer_size = xfer_size;
    buffers->tbs_ref = 1;
    return (buffers);
}

/*
 * tlm_release_buffers
 *
 * give all memory back to the OS
 */
void
tlm_release_buffers(tlm_buffers_t *buffers)
{
    int i;

    if (buffers != NULL) {
        tlm_buffer_release_in_buf(buffers);
        tlm_buffer_release_out_buf(buffers);

        (void) mutex_lock(&buffers->tbs_mtx);

        if (--buffers->tbs_ref <= 0) {
            for (i = 0; i < TLM_TAPE_BUFFERS; i++)
                free(buffers->tbs_buffer[i].tb_buffer_data);

        }

        (void) cond_destroy(&buffers->tbs_in_cv);
        (void) cond_destroy(&buffers->tbs_out_cv);
        (void) mutex_unlock(&buffers->tbs_mtx);
        (void) mutex_destroy(&buffers->tbs_mtx);
        free(buffers);
    }
}

/*
 * tlm_buffer_mark_empty
 *
 * Mark a buffer empty and clear its flags. No lock is take here:
 * the buffer should be marked empty before it is released for use
 * by another thread.
 */
void
tlm_buffer_mark_empty(tlm_buffer_t *buf)
{
    if (buf == NULL)
        return;

    buf->tb_full = buf->tb_eof = buf->tb_eot = FALSE;
    buf->tb_errno = 0;
}


/*
 * tlm_buffer_advance_in_idx
 *
 * Advance the input index of the buffers(round-robin) and return pointer
 * to the next buffer in the buffer pool.
 */
tlm_buffer_t *
tlm_buffer_advance_in_idx(tlm_buffers_t *bufs)
{
    if (bufs == NULL)
        return (NULL);

    (void) mutex_lock(&bufs->tbs_mtx);
    if (++bufs->tbs_buffer_in >= TLM_TAPE_BUFFERS)
        bufs->tbs_buffer_in = 0;

    (void) mutex_unlock(&bufs->tbs_mtx);
    return (&bufs->tbs_buffer[bufs->tbs_buffer_in]);
}


/*
 * tlm_buffer_advance_out_idx
 *
 * Advance the output index of the buffers(round-robin) and return pointer
 * to the next buffer in the buffer pool.
 */
tlm_buffer_t *
tlm_buffer_advance_out_idx(tlm_buffers_t *bufs)
{
    if (bufs == NULL)
        return (NULL);

    (void) mutex_lock(&bufs->tbs_mtx);
    if (++bufs->tbs_buffer_out >= TLM_TAPE_BUFFERS)
        bufs->tbs_buffer_out = 0;

    (void) mutex_unlock(&bufs->tbs_mtx);
    return (&bufs->tbs_buffer[bufs->tbs_buffer_out]);
}


/*
 * tlm_buffer_in_buf
 *
 * Return pointer to the next buffer in the buffer pool.
 */
tlm_buffer_t *
tlm_buffer_in_buf(tlm_buffers_t *bufs, int *idx)
{
    tlm_buffer_t *ret;

    if (bufs == NULL)
        return (NULL);

    (void) mutex_lock(&bufs->tbs_mtx);
    ret = &bufs->tbs_buffer[bufs->tbs_buffer_in];
    if (idx)
        *idx = bufs->tbs_buffer_in;
    (void) mutex_unlock(&bufs->tbs_mtx);
    return (ret);
}


/*
 * tlm_buffer_out_buf
 *
 * Return pointer to the next buffer in the buffer pool.
 */
tlm_buffer_t *
tlm_buffer_out_buf(tlm_buffers_t *bufs, int *idx)
{
    tlm_buffer_t *ret;

    if (bufs == NULL)
        return (NULL);

    (void) mutex_lock(&bufs->tbs_mtx);
    ret = &bufs->tbs_buffer[bufs->tbs_buffer_out];
    if (idx)
        *idx = bufs->tbs_buffer_out;
    (void) mutex_unlock(&bufs->tbs_mtx);
    return (ret);
}


/*
 * tlm_buffer_release_in_buf
 *
 * Another buffer is filled. Wake up the consumer if it's waiting for it.
 */
void
tlm_buffer_release_in_buf(tlm_buffers_t *bufs)
{
    (void) mutex_lock(&bufs->tbs_mtx);
    bufs->tbs_flags |= TLM_BUF_IN_READY;
    (void) cond_signal(&bufs->tbs_in_cv);
    (void) mutex_unlock(&bufs->tbs_mtx);
}


/*
 * tlm_buffer_release_out_buf
 *
 * A buffer is used. Wake up the producer to re-fill a buffer if it's waiting
 * for the buffer to be used.
 */
void
tlm_buffer_release_out_buf(tlm_buffers_t *bufs)
{
    (void) mutex_lock(&bufs->tbs_mtx);
    bufs->tbs_flags |= TLM_BUF_OUT_READY;
    (void) cond_signal(&bufs->tbs_out_cv);
    (void) mutex_unlock(&bufs->tbs_mtx);
}

/*
 * tlm_buffer_in_buf_wait
 *
 * Wait for the input buffer to get available.
 */
void
tlm_buffer_in_buf_wait(tlm_buffers_t *bufs)

{
    (void) mutex_lock(&bufs->tbs_mtx);

    while ((bufs->tbs_flags & TLM_BUF_IN_READY) == 0)
        (void) cond_wait(&bufs->tbs_in_cv, &bufs->tbs_mtx);

    bufs->tbs_flags &= ~TLM_BUF_IN_READY;

    (void) mutex_unlock(&bufs->tbs_mtx);
}

/*
 * tlm_buffer_setup_timer
 *
 * Set up the time out value.
 */
static inline void
tlm_buffer_setup_timer(timestruc_t *timo, unsigned milli_timo)
{
    if (milli_timo == 0)
        milli_timo = 1;

    if (milli_timo / 1000)
        timo->tv_sec = (milli_timo / 1000);
    else
        timo->tv_sec = 0;
    timo->tv_nsec = (milli_timo % 1000) * 1000000L;
}


/*
 * tlm_buffer_in_buf_timed_wait
 *
 * Wait for the input buffer to get ready with a time out.
 */
void
tlm_buffer_in_buf_timed_wait(tlm_buffers_t *bufs, unsigned int milli_timo)

{
    timestruc_t timo;

    tlm_buffer_setup_timer(&timo, milli_timo);

    (void) mutex_lock(&bufs->tbs_mtx);

    (void) cond_reltimedwait(&bufs->tbs_in_cv, &bufs->tbs_mtx, &timo);

    /*
     * TLM_BUF_IN_READY doesn't matter for timedwait but clear
     * it here so that cond_wait doesn't get the wrong result.
     */
    bufs->tbs_flags &= ~TLM_BUF_IN_READY;

    (void) mutex_unlock(&bufs->tbs_mtx);
}


/*
 * tlm_buffer_out_buf_timed_wait
 *
 * Wait for the output buffer to get ready with a time out.
 */
void
tlm_buffer_out_buf_timed_wait(tlm_buffers_t *bufs, unsigned int milli_timo)
{
    timestruc_t timo;

    tlm_buffer_setup_timer(&timo, milli_timo);

    (void) mutex_lock(&bufs->tbs_mtx);

    (void) cond_reltimedwait(&bufs->tbs_out_cv, &bufs->tbs_mtx, &timo);

    /*
     * TLM_BUF_OUT_READY doesn't matter for timedwait but clear
     * it here so that cond_wait doesn't get the wrong result.
     */
    bufs->tbs_flags &= ~TLM_BUF_OUT_READY;

    (void) mutex_unlock(&bufs->tbs_mtx);
}


/*
 * tlm_cmd_wait
 *
 * TLM command synchronization typically use by command
 * parent threads to wait for launched threads to initialize.
 */
void
tlm_cmd_wait(tlm_cmd_t *cmd, uint32_t event_type)
{
    (void) mutex_lock(&cmd->tc_mtx);

    while ((cmd->tc_flags & event_type) == 0)
        (void) cond_wait(&cmd->tc_cv, &cmd->tc_mtx);

    cmd->tc_flags &= ~event_type;
    (void) mutex_unlock(&cmd->tc_mtx);
}


/*
 * tlm_cmd_signal
 *
 * TLM command synchronization typically use by launched threads
 * to unleash the parent thread.
 */
void
tlm_cmd_signal(tlm_cmd_t *cmd, uint32_t event_type)
{
    (void) mutex_lock(&cmd->tc_mtx);

    cmd->tc_flags |= event_type;
    (void) cond_signal(&cmd->tc_cv);

    (void) mutex_unlock(&cmd->tc_mtx);
}