ocs_io.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. Neither the name of the copyright holder 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 HOLDER 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.
 *
 */

/**
 * @file
 * Provide IO object allocation.
 */

/*!
 * @defgroup io_alloc IO allocation
 */

#include "ocs.h"
#include "ocs_scsi_fc.h"
#include "ocs_pool.h"

void ocs_mgmt_io_list(ocs_textbuf_t *textbuf, void *io);
void ocs_mgmt_io_get_all(ocs_textbuf_t *textbuf, void *io);
int ocs_mgmt_io_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *io);

static ocs_mgmt_functions_t io_mgmt_functions = {
    .get_list_handler   =   ocs_mgmt_io_list,
    .get_handler        =   ocs_mgmt_io_get,
    .get_all_handler    =   ocs_mgmt_io_get_all,
};

/**
 * @brief IO pool.
 *
 * Structure encapsulating a pool of IO objects.
 *
 */

struct ocs_io_pool_s {
    ocs_t *ocs;         /* Pointer to device object */
    ocs_lock_t lock;        /* IO pool lock */
    uint32_t io_num_ios;        /* Total IOs allocated */
    ocs_pool_t *pool;
};

/**
 * @brief Create a pool of IO objects.
 *
 * @par Description
 * This function allocates memory in larger chucks called
 * "slabs" which are a fixed size. It calculates the number of IO objects that
 * fit within each "slab" and determines the number of "slabs" required to
 * allocate the number of IOs requested. Each of the slabs is allocated and
 * then it grabs each IO object within the slab and adds it to the free list.
 * Individual command, response and SGL DMA buffers are allocated for each IO.
 *
 *           "Slabs"
 *      +----------------+
 *      |                |
 *   +----------------+  |
 *   |    IO          |  |
 *   +----------------+  |
 *   |    ...         |  |
 *   +----------------+__+
 *   |    IO          |
 *   +----------------+
 *
 * @param ocs Driver instance's software context.
 * @param num_io Number of IO contexts to allocate.
 * @param num_sgl Number of SGL entries to allocate for each IO.
 *
 * @return Returns a pointer to a new ocs_io_pool_t on success,
 *         or NULL on failure.
 */

ocs_io_pool_t *
ocs_io_pool_create(ocs_t *ocs, uint32_t num_io, uint32_t num_sgl)
{
    uint32_t i = 0;
    int32_t rc = -1;
    ocs_io_pool_t *io_pool;

    /* Allocate the IO pool */
    io_pool = ocs_malloc(ocs, sizeof(*io_pool), OCS_M_ZERO | OCS_M_NOWAIT);
    if (!io_pool) {
        ocs_log_err(ocs, "allocate of IO pool failed\n");
        goto free_io_pool;
    }

    io_pool->ocs = ocs;
    io_pool->io_num_ios = num_io;

    /* initialize IO pool lock */
    ocs_lock_init(ocs, &io_pool->lock, "io_pool lock[%d]", ocs->instance_index);

    io_pool->pool = ocs_pool_alloc(ocs, sizeof(ocs_io_t), io_pool->io_num_ios, FALSE);
    if (!io_pool->pool) {
        ocs_log_err(ocs, "allocation of memory IO pool failed\n");
        goto free_io_pool;
    }

    for (i = 0; i < io_pool->io_num_ios; i++) {
        ocs_io_t *io = ocs_pool_get_instance(io_pool->pool, i);
        if (!io) {
            ocs_log_err(ocs, "ocs_pool_get_instance failed\n");
            goto free_io_pool;
        }

        io->tag = i;
        io->instance_index = i;
        io->ocs = ocs;

        /* allocate a command/response dma buffer */
        if (ocs->enable_ini) {
            rc = ocs_dma_alloc(ocs, &io->cmdbuf, SCSI_CMD_BUF_LENGTH, OCS_MIN_DMA_ALIGNMENT);
            if (rc) {
                ocs_log_err(ocs, "ocs_dma_alloc cmdbuf failed\n");
                goto free_io_pool;
            }
        }

        /* Allocate a response buffer */
        rc = ocs_dma_alloc(ocs, &io->rspbuf, SCSI_RSP_BUF_LENGTH, OCS_MIN_DMA_ALIGNMENT);
        if (rc) {
            ocs_log_err(ocs, "ocs_dma_alloc rspbuf failed\n");
            goto free_io_pool;
        }

        /* Allocate SGL */
        io->sgl_allocated = num_sgl;
        io->sgl_count = 0;
        io->sgl = ocs_malloc(ocs, sizeof(*io->sgl) * num_sgl, OCS_M_NOWAIT | OCS_M_ZERO);
        if (!io->sgl) {
            ocs_log_err(ocs, "malloc sgl's failed\n");
            goto free_io_pool;
        }

        /* Make IO backend call to initialize IO */
        ocs_scsi_tgt_io_init(io);
        ocs_scsi_ini_io_init(io);
    }

    return io_pool;

free_io_pool:
    ocs_io_pool_free(io_pool);
    return NULL;
}

/**
 * @brief Free IO objects pool
 *
 * @par Description
 * The pool of IO objects are freed.
 *
 * @param io_pool Pointer to IO pool object.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */
int32_t
ocs_io_pool_free(ocs_io_pool_t *io_pool)
{
    ocs_t *ocs;
    uint32_t i;
    ocs_io_t *io;

    if (!io_pool) {
        return 0;
    }

    ocs = io_pool->ocs;
    if (io_pool->pool) {
        for (i = 0; i < io_pool->io_num_ios; i++) {
            io = ocs_pool_get_instance(io_pool->pool, i);
            if (!io) {
                continue;
            }

            ocs_scsi_tgt_io_exit(io);
            ocs_scsi_ini_io_exit(io);

            if (io->sgl) {
                ocs_free(ocs, io->sgl, sizeof(*io->sgl) * io->sgl_allocated);
                io->sgl = NULL;
            }
            io->sgl_allocated = 0;

            ocs_dma_free(ocs, &io->cmdbuf);
            ocs_dma_free(ocs, &io->rspbuf);
        }

        ocs_pool_free(io_pool->pool);
    }

    ocs_lock_free(&io_pool->lock);
    ocs_free(ocs, io_pool, sizeof(*io_pool));
    ocs->xport->io_pool = NULL;
    return 0;
}

uint32_t ocs_io_pool_allocated(ocs_io_pool_t *io_pool)
{
    return io_pool->io_num_ios;
}

/**
 * @ingroup io_alloc
 * @brief Allocate an object used to track an IO.
 *
 * @param io_pool Pointer to the IO pool.
 *
 * @return Returns the pointer to a new object, or NULL if none available.
 */
ocs_io_t *
ocs_io_pool_io_alloc(ocs_io_pool_t *io_pool)
{
    ocs_io_t *io = NULL;
    ocs_t *ocs;

    ocs_assert(io_pool, NULL);

    ocs = io_pool->ocs;

    ocs_lock(&io_pool->lock);
    if ((io = ocs_pool_get(io_pool->pool)) != NULL) {
        ocs_unlock(&io_pool->lock);

        io->io_type = OCS_IO_TYPE_MAX;
        io->hio_type = OCS_HAL_IO_MAX;
        io->hio = NULL;
        io->transferred = 0;
        io->ocs = ocs;
        io->timeout = 0;
        io->sgl_count = 0;
        io->tgt_task_tag = 0;
        io->init_task_tag = 0;
        io->hw_tag = 0;
        io->display_name = "pending";
        io->seq_init = 0;
        io->els_req_free = 0;
        io->mgmt_functions = &io_mgmt_functions;
        io->io_free = 0;
        ocs_atomic_add_return(&ocs->xport->io_active_count, 1);
        ocs_atomic_add_return(&ocs->xport->io_total_alloc, 1);
    } else {
        ocs_unlock(&io_pool->lock);
    }
    return io;
}

/**
 * @ingroup io_alloc
 * @brief Free an object used to track an IO.
 *
 * @param io_pool Pointer to IO pool object.
 * @param io Pointer to the IO object.
 */
void
ocs_io_pool_io_free(ocs_io_pool_t *io_pool, ocs_io_t *io)
{
    ocs_t *ocs;
    ocs_hal_io_t *hio = NULL;

    ocs_assert(io_pool);

    ocs = io_pool->ocs;

    ocs_lock(&io_pool->lock);
        hio = io->hio;
        io->hio = NULL;
        io->io_free = 1;
        ocs_pool_put_head(io_pool->pool, io);
    ocs_unlock(&io_pool->lock);

    if (hio) {
        ocs_hal_io_free(&ocs->hal, hio);
    }
    ocs_atomic_sub_return(&ocs->xport->io_active_count, 1);
    ocs_atomic_add_return(&ocs->xport->io_total_free, 1);
}

/**
 * @ingroup io_alloc
 * @brief Find an I/O given it's node and ox_id.
 *
 * @param ocs Driver instance's software context.
 * @param node Pointer to node.
 * @param ox_id OX_ID to find.
 * @param rx_id RX_ID to find (0xffff for unassigned).
 */
ocs_io_t *
ocs_io_find_tgt_io(ocs_t *ocs, ocs_node_t *node, uint16_t ox_id, uint16_t rx_id)
{
    ocs_io_t    *io = NULL;

    ocs_lock(&node->active_ios_lock);
        ocs_list_foreach(&node->active_ios, io)
            if ((io->cmd_tgt && (io->init_task_tag == ox_id)) &&
                ((rx_id == 0xffff) || (io->tgt_task_tag == rx_id))) {
                break;
            }
    ocs_unlock(&node->active_ios_lock);
    return io;
}
/**
 * @ingroup ocs_io_find_init_els_io
 * @brief Find an els I/O given it's node and ox_id.
 *
 * @param ocs Driver instance's software context.
 * @param node Pointer to node.
 * @param ox_id OX_ID to find.
 */

ocs_io_t *
ocs_io_find_init_els_io(ocs_t *ocs, ocs_node_t *node, uint16_t ox_id)
{
    ocs_io_t    *io = NULL;

    ocs_lock(&node->active_ios_lock);
        ocs_list_foreach(&node->els_io_active_list, io) {
            if ((io->cmd_ini && (io->init_task_tag == ox_id))) {
                break;
            }
        }
    ocs_unlock(&node->active_ios_lock);
    return io;
}

/**
 * @ingroup io_alloc
 * @brief Return IO context given the instance index.
 *
 * @par Description
 * Returns a pointer to the IO context given by the instance index.
 *
 * @param ocs Pointer to driver structure.
 * @param index IO instance index to return.
 *
 * @return Returns a pointer to the IO context, or NULL if not found.
 */
ocs_io_t *
ocs_io_get_instance(ocs_t *ocs, uint32_t index)
{
    ocs_xport_t *xport = ocs->xport;
    ocs_io_pool_t *io_pool = xport->io_pool;
    return ocs_pool_get_instance(io_pool->pool, index);
}

/**
 * @brief Generate IO context ddump data.
 *
 * The ddump data for an IO context is generated.
 *
 * @param textbuf Pointer to text buffer.
 * @param io Pointer to IO context.
 *
 * @return None.
 */

void
ocs_ddump_io(ocs_textbuf_t *textbuf, ocs_io_t *io)
{
    ocs_ddump_section(textbuf, "io", io->instance_index);
    ocs_ddump_value(textbuf, "display_name", "%s", io->display_name);
    ocs_ddump_value(textbuf, "node_name", "%s", io->node->display_name);

    ocs_ddump_value(textbuf, "ref_count", "%d", ocs_ref_read_count(&io->ref));
    ocs_ddump_value(textbuf, "io_type", "%d", io->io_type);
    ocs_ddump_value(textbuf, "hio_type", "%d", io->hio_type);
    ocs_ddump_value(textbuf, "cmd_tgt", "%d", io->cmd_tgt);
    ocs_ddump_value(textbuf, "cmd_ini", "%d", io->cmd_ini);
    ocs_ddump_value(textbuf, "send_abts", "%d", io->send_abts);
    ocs_ddump_value(textbuf, "init_task_tag", "0x%x", io->init_task_tag);
    ocs_ddump_value(textbuf, "tgt_task_tag", "0x%x", io->tgt_task_tag);
    ocs_ddump_value(textbuf, "hw_tag", "0x%x", io->hw_tag);
    ocs_ddump_value(textbuf, "tag", "0x%x", io->tag);
    ocs_ddump_value(textbuf, "timeout", "%d", io->timeout);
    ocs_ddump_value(textbuf, "tmf_cmd", "%d", io->tmf_cmd);
    ocs_ddump_value(textbuf, "abort_rx_id", "0x%x", io->abort_rx_id);
#if defined(OCS_INCLUDE_SCST)
    ocs_ddump_value(textbuf, "iostate", "%08x", ocs_scsi_tgt_io_state(io));
#endif
    ocs_ddump_value(textbuf, "busy", "%d", ocs_io_busy(io));
    ocs_ddump_value(textbuf, "transferred", "%zu", io->transferred);
    ocs_ddump_value(textbuf, "auto_resp", "%d", io->auto_resp);
    ocs_ddump_value(textbuf, "exp_xfer_len", "%d", io->exp_xfer_len);
    ocs_ddump_value(textbuf, "xfer_req", "%" PRIu64, io->xfer_req);
    ocs_ddump_value(textbuf, "seq_init", "%d", io->seq_init);

    ocs_ddump_value(textbuf, "alloc_link", "%d", ocs_list_on_list(&io->io_alloc_link));
    ocs_ddump_value(textbuf, "pending_link", "%d", ocs_list_on_list(&io->io_pending_link));
    ocs_ddump_value(textbuf, "backend_link", "%d", ocs_list_on_list(&io->link));
    
    if (io->hio) {
        ocs_ddump_value(textbuf, "hal_tag", "%#x", io->hio->reqtag);
        ocs_ddump_value(textbuf, "hal_xri", "%#x", io->hio->indicator);
        ocs_ddump_value(textbuf, "hal_type", "%#x", io->hio->type);
    } else {
        ocs_ddump_value(textbuf, "hal_tag", "%s", "pending");
        ocs_ddump_value(textbuf, "hal_xri", "%s", "pending");
        ocs_ddump_value(textbuf, "hal_type", "%s", "pending");
    }

    ocs_scsi_ini_ddump(textbuf, OCS_SCSI_DDUMP_IO, io);
    ocs_scsi_tgt_ddump(textbuf, OCS_SCSI_DDUMP_IO, io);

    ocs_ddump_endsection(textbuf, "io", io->instance_index);
}


void
ocs_mgmt_io_list(ocs_textbuf_t *textbuf, void *object)
{

    /* Readonly values */
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "display_name");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "init_task_tag");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "tag");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "transferred");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "auto_resp");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "exp_xfer_len");
    ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "xfer_req");
}

int
ocs_mgmt_io_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
{
    char qualifier[80];
    int retval = -1;
    ocs_io_t *io = (ocs_io_t *) object;

    snprintf(qualifier, sizeof(qualifier), "%s/io[%d]", parent, io->instance_index);

    /* If it doesn't start with my qualifier I don't know what to do with it */
    if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
        char *unqualified_name = name + strlen(qualifier) +1;

        /* See if it's a value I can supply */
        if (ocs_strcmp(unqualified_name, "display_name") == 0) {
            ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", io->display_name);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "init_task_tag") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "init_task_tag", "0x%x", io->init_task_tag);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tgt_task_tag") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tgt_task_tag", "0x%x", io->tgt_task_tag);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "hw_tag") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_tag", "0x%x", io->hw_tag);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "tag") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tag", "0x%x", io->tag);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "transferred") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "transferred", "%zu", io->transferred);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "auto_resp") == 0) {
            ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "auto_resp", io->auto_resp);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "exp_xfer_len") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "exp_xfer_len", "%d", io->exp_xfer_len);
            retval = 0;
        } else if (ocs_strcmp(unqualified_name, "xfer_req") == 0) {
            ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "xfer_req", "%" PRIu64, io->xfer_req);
            retval = 0;
        }
    }

    return retval;
}

void
ocs_mgmt_io_get_all(ocs_textbuf_t *textbuf, void *object)
{
    ocs_io_t *io = (ocs_io_t *) object;

    ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", io->display_name);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "init_task_tag", "0x%x", io->init_task_tag);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tgt_task_tag", "0x%x", io->tgt_task_tag);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_tag", "0x%x", io->hw_tag);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tag", "0x%x", io->tag);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "transferred", "%zu", io->transferred);
    ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "auto_resp", io->auto_resp);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "exp_xfer_len", "%d", io->exp_xfer_len);
    ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "xfer_req", "%" PRIu64, io->xfer_req);

}