ocs_scsi_tgt.h

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
 * Declares the target specific structures required by the base driver
 */

#if !defined(__OCS_SCSI_TGT_H__)
#define __OCS_SCSI_TGT_H__

#define OCS_INCLUDE_RAMD

#include "ocs_scsi.h"
#include "ocs_ramdisc.h"
#include "ocs_ramd_thread.h"

/**
 * @brief target private ocs structure
 */

typedef struct {
    uint32_t max_sge;
    uint32_t max_sgl;

    /*
     * Variables used to send task set full. We are using a high watermark
     * method to send task set full. We will reserve a fixed number of IOs
     * per initiator plus a fudge factor. Once we reach this number,
     * then the target will start sending task set full/busy responses.
     */
    ocs_atomic_t initiator_count;       /**< count of initiators */
    uint32_t enable_task_set_full;      /**< enable generation of task set full */
    ocs_atomic_t io_high_watermark;     /**< used to send task set full */
    ocs_atomic_t watermark_hit;     /**< used to track how often IO pool almost empty */
    int32_t watermark_min;          /**< lower limit for watermark */
    int32_t watermark_max;          /**< upper limit for watermark */

    /* RAM disk */
    uint8_t use_global_ramd;    /**< flag to allocate globally or on sport */
    ocs_ramdisc_t **rdisc;      /**< pointer to array of ramdisc instances, one per LUN */
    uint32_t rdisc_count;       /**< count of ramdisc instances */

    ocs_list_t port_rdisc_head;
} ocs_scsi_tgt_t;

/**
 * @brief target private domain structure
 */

typedef struct {
    /* ocs_ramd decls */
    ;
} ocs_scsi_tgt_domain_t;

/**
 * @brief target private sport structure
 */

typedef struct {
    /* ocs_ramd decls - Used when allocating ramdisk on sport instead of globally */
    ocs_ramdisc_t **rdisc;      /**< pointer to array of ramdisc instances, one per LUN */
    uint32_t rdisc_count;       /**< count of ramdisc instances */
} ocs_scsi_tgt_sport_t;

/**
 * @brief ocs_ramdisc_ua_t represents a single UNIT ATTENTION condition
 */

typedef struct ocs_ramdisc_ua_s {
    uint8_t         asc;
    uint8_t         ascq;
    ocs_list_link_t     link;
} ocs_ramdisc_ua_t;

/**
 * @brief ocs_ramdisc_ua_t is a collection of UNIT ATTENTION conditions
 *
 * SAM 5.14 refers to this as a "queue of unit attention conditions of
 * unspecified order" but there's no reason it needs to be
 * a queue.  In this implementation it will be a list
 */
typedef struct ocs_ramdisc_ua_queue_s {
    ocs_lock_t      ua_queue_lock;
    uint32_t        num_entries;
    ocs_list_t      entry_list;
} ocs_ramdisc_ua_queue_t;


/**
 * @brief target private node structure
 *
 * This structure holds information that relates to a node (I_T nexus)
 * that is owned and used by the target.
 *
 * ua_queues is a dynamically allocated list of ocs_ramdisc_ua_queue_t
 * The list is allocated by ocs_scsi_new_initiator when a new initiator
 * is discovered.  There is a one ua_queue for each LUN
 */

typedef struct {
    uint32_t        num_ua_queues;
    ocs_ramdisc_ua_queue_t  *ua_queues;
} ocs_scsi_tgt_node_t;

/**
 * @brief target private IO structure
 */

typedef struct {
    /* save input arguments */
    uint32_t flags;             /**< flags */
    ocs_dma_t *first_burst_buffers;     /**< array of DMA first burst buffers */
    void *pcmd;             /**< pointer to scsi_cmd_table_t */
    uint8_t has_first_burst;        /**< flag indicating that command has first burst */
    uint8_t cdb[OCS_SCSI_MAX_CDB_LEN];  /**< CDB */
    uint32_t cdb_len;           /**< length of CDB */

    uint64_t io_lba;            /**< The starting LBA */
    uint32_t first_burst_bytes;     /**< Number of bytes in first burst */
    ocs_scsi_dif_info_t dif_info;       /**< DIF information */

    uint8_t mode_select_opcode;     /**< Mode select command opcode */

    /* Deferred status send when waiting for first burst to complete*/
    uint8_t send_task_set_full:1,       /**< if TRUE, then send task set full status after first burst */
        send_check_cond:1;      /**< if TRUE, then send check condition response after first burst */
    uint8_t send_sense_key;         /**< response sense key if send_check_cond */
    uint8_t send_asc;           /**< response asc if send_check_cond */
    uint8_t send_ascq;          /**< response ascq if send_check_cond */

    /* target server */
    uint32_t lun;               /**< LUN */
    ocs_ramdisc_t *ramdisc;         /**< Pointer to ramdisc object */
    uint8_t lun_is_valid;           /**< flag indicating that the LUN value is valid */

    uint8_t is_read;            /**< flag to identify reads */

    /* Block command variables */
    uint32_t io_block_count;        /**< request IO size in blocks */
    uint32_t acc_block_count;       /**< accumulated block count, updated after successful dataphase */
    uint64_t cur_lba;           /**< current dataphase LBA */
    uint32_t cur_block_count;       /**< current dataphase block count */
    uint32_t sgl_phys:1;            /**< if set, then build phys SGL (data+DIF) */

    ocs_dma_t payload;          /**< payload for commands that need it */
    uint8_t supress_auto_response;      /**< disable auto response if true */

    /* Values saved from the CDB for the FORMAT UNIT commands */
    uint8_t fmtpinfo;           /**< FMTPINFO value */

    /* Values saved from the CDB for the WRITE SAME commands */
    uint8_t pbdata;             /**< PBDATA flag */
    uint8_t lbdata;             /**< LBDATA flag */
    uint8_t wrprotect;          /**< WRPROTECT value */
    uint32_t num_blocks;            /**< NUMBER OF LOCICAL BLOCKS value */

    /* Abort Task */
    ocs_io_t *tmfio;            /**< Pointer to the TMF IO object for an abort task */

    ocs_lock_t sm_lock;         /**< SM lock, to serialize execution while in multi-threaded environment */
    ocs_sm_ctx_t sm;            /**< SCSI ramdisc I/O state machine context */
    uint8_t current_state;          /**< current state of IO state machine */

    ocs_ramd_thread_t *thr;
} ocs_scsi_tgt_io_t;

#endif /* __OCS_SCSI_TGT_H__ */