/*
 * 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);
}