mode_sense.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
 * Mode sense SCSI command processing
 */


#include "ocs.h"
#include "ocs_ramd.h"



/* Mode Sense page parameter data */

/* Mode Sense Declarations */


/**
 * @brief Defines the mode sense 6 parameter header.
 */
struct mode_parameter_header6_s {
    unsigned mode_data_length:8;
    unsigned medium_type:8;
    unsigned device_specific_parameter:8;
    unsigned block_descriptor_length:8;
    };

/**
 * @brief Defines the mode sense 10 parameter header.
 */
struct mode_parameter_header10_s {
    unsigned mode_data_length:16;
    unsigned medium_type:8;
    unsigned device_specific_parameter:8;
    unsigned longlba:1;
    unsigned _1_:7;
    unsigned _2_:8;
    unsigned block_descriptor_length:16;
    };

/**
 * @brief Defines the mode sense parameter block descriptor.
 */
struct mode_parameter_block_descriptor_s {
    unsigned number_of_blocks:32;
    unsigned _1_:8;
    unsigned block_length:24;
    };

/**
 * @brief Defines the mode sense long parameter block descriptor.
 */
struct mode_parameter_long_block_descriptor_s {
    uint64_t number_of_blocks;
    unsigned _1_:32;
    unsigned block_length:32;
    };

#define MODE_SENSE_ALL_PAGES        0x3f
#define MODE_SENSE_PC_CURRENT       0x0
#define MODE_SENSE_PC_CHANGEABLE    0x1
#define MODE_SENSE_PC_DEFAULT       0x2
#define MODE_SENSE_PC_SAVED     0x3

/* (error recovery) pcd */
static uint8_t mode_parameter_page_01[] = {
    0x01, 0x0a, 0x0c, 0x4b,
    0x30, 0x00, 0x00, 0x00,
    0x29, 0x00, 0xff, 0xff, };

/* (disconnect-reconnect) pcd */
static uint8_t mode_parameter_page_02[] = {
    0x02, 0x0e, 0x80, 0x80, /* Buffer ratios */
    0x00, 0x00, 0x00, 0x00, /* Bus inactivity limit/Disconnect time limit */
    0x00, 0x00, 0x02, 0x84, /* Connect Time Limit/Max burst size */
    0x00, 0x00, 0x00, 0x04, }; /* first burst = 2048 bytes */

/* (format device) pcd */
static uint8_t mode_parameter_page_03[] = {
    0x03, 0x16, 0x00, 0x01,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x40,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, };

/* (rigid disk geometry) pcd */
static uint8_t mode_parameter_page_04[] = {
    0x04, 0x16, 0x00, 0x01,
    0x01, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x1c, 0x20, 0x00, 0x00, };

/* (verify error recovery) pcd */
static uint8_t mode_parameter_page_07[] = {
    0x07, 0x0a, 0x00, 0x4b,
    0x30, 0x00, 0x00, 0x00,
    0x00, 0x00, 0xff, 0xff, };

/* (caching) pcd */
static uint8_t mode_parameter_page_08[] = {
    0x08, 0x12, 0x10, 0x00,
    0xff, 0xff, 0x00, 0x00,
    0xff, 0xff, 0xff, 0xff,
    0x80, 0x03, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, };

/* (control) pcd */
static uint8_t mode_parameter_page_0a[] = {
    0x0a, 0x0a, 0x02, 0x00,
    0x00, 0x80, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, };

/* Protocol Specific Logical Unit */
static uint8_t mode_parameter_page_18[] = {
    0x18, 0x06, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, };

/* (info exceptions control) pcd */
static uint8_t mode_parameter_page_1c[] = {
    0x1c, 0x0a, 0x00, 0x00,
    0xff, 0xff, 0xff, 0xff,
    0x00, 0x00, 0x00, 0x00, };

/* (vendor-specific) pcd */
static uint8_t mode_parameter_page_00[] = {
    0x00, 0x02, 0x00, 0x00, };

/**
 * @brief internal structure for mode sense parameter data pages.
 */
struct mode_parameter_data_s {
    uint8_t page;
    uint8_t *parameter_data;
    uint32_t parameter_data_length;
    };

static struct mode_parameter_data_s mode_parameter_data[] = {
    {0x01, mode_parameter_page_01, sizeof(mode_parameter_page_01)},
    {0x02, mode_parameter_page_02, sizeof(mode_parameter_page_02)},
    {0x03, mode_parameter_page_03, sizeof(mode_parameter_page_03)},
    {0x04, mode_parameter_page_04, sizeof(mode_parameter_page_04)},
    {0x07, mode_parameter_page_07, sizeof(mode_parameter_page_07)},
    {0x08, mode_parameter_page_08, sizeof(mode_parameter_page_08)},
    {0x0a, mode_parameter_page_0a, sizeof(mode_parameter_page_0a)},
    {0x18, mode_parameter_page_18, sizeof(mode_parameter_page_18)},
    {0x1c, mode_parameter_page_1c, sizeof(mode_parameter_page_1c)},
    {0x00, mode_parameter_page_00, sizeof(mode_parameter_page_00)} };

static ocs_ramd_hndlr_rtn_e ocs_ramd_mode_sense(ocs_io_t *io, uint32_t hdrsize, uint8_t cdb[]);

static int tm_mode_page_supported(int page)
{
    struct mode_parameter_data_s *param;

    uint32_t mode_parameter_data_count = (sizeof(mode_parameter_data) /
        sizeof(mode_parameter_data[0]));
    uint32_t i;

    for (i = 0, param = mode_parameter_data; i < mode_parameter_data_count;
        i++, param++)
        if (param->page == page)
            return 1;
    return 0;
}

static uint32_t ocs_htobe24(uint32_t value)
{
    return  ((value >> 16)  & 0xff) |
        ((value)    & 0xff00) |
        ((value << 16)  & 0xff0000);
}

static int tm_build_mode_parameter(ocs_io_t *io, int page, int dbd, int llbaa, int hdrsize,
    uint8_t *buffer, uint32_t buffer_length)
{
    uint32_t lun = io->tgt_io.lun;
    int shortdesc = !dbd && !llbaa;
    int longdesc = !dbd && llbaa;
    struct mode_parameter_data_s *param;
    uint32_t i;
    uint32_t mode_parameter_data_count = (sizeof(mode_parameter_data) /
        sizeof(mode_parameter_data[0]));
    struct mode_parameter_header6_s *hdr6 = NULL;
    struct mode_parameter_header10_s *hdr10 = NULL;
    struct mode_parameter_block_descriptor_s *desc = NULL;
    struct mode_parameter_long_block_descriptor_s *ldesc = NULL;
    uint8_t *parameter_data = NULL;
    uint32_t length = 0;
    uint32_t block_size;
    uint32_t payload_length = 0;
    uint8_t *local_buffer;
    uint8_t *local_ptr;
    ocs_ramdisc_t *ramdisc;
    ocs_t *ocs = io->ocs;

    ramdisc = ocs_ramd_lookup(io, lun);

    ocs_memset(buffer, 0, buffer_length);

    length += (hdrsize == 6) ? sizeof(struct mode_parameter_header6_s) :
        sizeof(struct mode_parameter_header10_s);
    if (shortdesc)
        length += sizeof(struct mode_parameter_block_descriptor_s);
    if (longdesc)
        length += sizeof(struct mode_parameter_long_block_descriptor_s);
    for (i = 0, param = mode_parameter_data; i < mode_parameter_data_count;
        i++, param++)
        if ((page == MODE_SENSE_ALL_PAGES) || (param->page == page))
            length += param->parameter_data_length;

    /* allocate a local buffer */
    local_buffer = ocs_malloc(ocs, length, OCS_M_NOWAIT);
    if (!local_buffer)
        return -1;

    ocs_memset(local_buffer, 0, length);

    /* assign header, descriptor block and parameter data pointers */
    local_ptr = local_buffer;
    if (hdrsize == 6) {
        hdr6 = (struct mode_parameter_header6_s *) local_ptr;
        local_ptr += sizeof(struct mode_parameter_header6_s);
    } else {
        hdr10 = (struct mode_parameter_header10_s *) local_ptr;
        local_ptr += sizeof(struct mode_parameter_header10_s);
    }

    /* assign descriptor block  */
    if (longdesc) {
        ldesc =
            (struct mode_parameter_long_block_descriptor_s *)local_ptr;
        local_ptr +=
            sizeof(struct mode_parameter_long_block_descriptor_s);
    }
    if (shortdesc) {
        desc = (struct mode_parameter_block_descriptor_s *)local_ptr;
        local_ptr += sizeof(struct mode_parameter_block_descriptor_s);
    }
    /* assign pointer to parameter data */
    parameter_data = local_ptr;

    /* fill in header */
    if (hdr6) {
        hdr6->mode_data_length = length - 1;
        hdr6->medium_type = 0;
        hdr6->device_specific_parameter = 0x10;
        if (shortdesc)
            hdr6->block_descriptor_length =
                sizeof(struct mode_parameter_block_descriptor_s);
    }
    if (hdr10) {
        hdr10->mode_data_length = ocs_htobe16(length - 2);
        hdr10->medium_type = 0;
        hdr10->device_specific_parameter = 0x10;
        hdr10->longlba = llbaa;
        if (shortdesc)
            hdr10->block_descriptor_length =
                ocs_htobe16(sizeof(
                struct mode_parameter_block_descriptor_s));
        if (longdesc)
            hdr10->block_descriptor_length =
                ocs_htobe16(sizeof(
                struct mode_parameter_long_block_descriptor_s));
    }

    /* fill in block descriptor (if defined)
     * If the ramdisc has protection enabled then the logical block size, which report here,
     * is actually 8 bytes shorter than the formatted block size because we report the size
     * of the user data area with the DIF data
     */
    block_size = ramdisc->data_block_size;

    if (shortdesc) {
        desc->number_of_blocks = ocs_htobe32(ramdisc->block_count);
        desc->block_length = ocs_htobe24(block_size);
    }

    if (longdesc) {
        ldesc->number_of_blocks =
            ocs_htobe64(ramdisc->block_count);
        ldesc->block_length = ocs_htobe32(block_size);
    }

    /* fill in page data */
    local_ptr = parameter_data;
    for (i = 0, param = mode_parameter_data; i < mode_parameter_data_count;
            i++, param++)
        if ((page == MODE_SENSE_ALL_PAGES) || (param->page == page)) {

            /* Check for ATO in control page (0xa) */
#define tm_prot_luns (0)
/* Values for tm_prot_mode */
#define TM_PROT_MODE_DEFAULT        0x0
#define TM_PROT_MODE_END2END        0x1
#define TM_PROT_MODE_WIRE_ONLY      0x2
#define TM_PROT_MODE_HOST_ONLY      0x3
#define tm_prot_mode TM_PROT_MODE_DEFAULT

            if (param->page == 0xa) {
                if (tm_prot_luns &&
                    (tm_prot_mode != TM_PROT_MODE_HOST_ONLY))
                    param->parameter_data[5] |= 0x80;
                else
                    param->parameter_data[5] &= ~0x80;
            } else if (param->page == 2) {
                /*
                 * Update the first burst size is the
                 * disconnect/reconnect mode page.
                 */
                ocs_t *ocs = io->ocs;
                uint32_t fburst = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_FIRST_BURST) / 512;
                param->parameter_data[14] = (fburst >> 8) & 0xff;
                param->parameter_data[15] = fburst & 0xff;
            }

            ocs_memcpy(local_ptr, param->parameter_data,
            param->parameter_data_length);
            local_ptr += param->parameter_data_length;
        }

    /* copy to buffer */
    payload_length = (buffer_length < length) ? buffer_length : length;
    ocs_memcpy(buffer, local_buffer, payload_length);

    /* free local buffer */
    ocs_free(ocs, local_buffer, length);

    /* return length of payload */
    return payload_length;
}

/**
 * @ingroup scsi_cmd
 * @brief Process SCSI Mode Sense 6 command
 *
 * The SCSI Mode Sense 6 command is processed
 *
 * @param io pointer to IO context
 * @param cdb pointer to SCSI cdb
 *
 * @return returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 *         and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */

ocs_ramd_hndlr_rtn_e ocs_ramd_mode_sense6(ocs_io_t *io, uint8_t cdb[]) {
    return ocs_ramd_mode_sense(io, 6, cdb);
}

/**
 * @ingroup scsi_cmd
 * @brief Process SCSI Mode Sense 10 command
 *
 * The SCSI Mode Sense 10 command is processed
 *
 * @param io pointer to IO context
 * @param cdb pointer to SCSI cdb
 *
 * @return returns the handler status for the command. SCSI_HANDLER_NOT_STARTED
 *         and SCSI_CMD_NOT_SUPPORTED are errors and the IO should be freed.
 */

ocs_ramd_hndlr_rtn_e ocs_ramd_mode_sense10(ocs_io_t *io, uint8_t cdb[]) {
    return ocs_ramd_mode_sense(io, 10, cdb);
}

static ocs_ramd_hndlr_rtn_e ocs_ramd_mode_sense(ocs_io_t *io, uint32_t hdrsize, uint8_t cdb[]) {
    uint32_t allocation_len;
    uint8_t page;
    //uint8_t subpage;
    uint8_t dbd;
    uint8_t pc;
    uint32_t mode_sense_len;
    uint8_t llbaa = 0;
    ocs_ramd_hndlr_rtn_e rc;
    ocs_scsi_sgl_t sgl[1];

    dbd = (cdb[1] & 0x08) != 0;
    page = cdb[2] & 0x3f;
    pc = (cdb[2] >> 6) & 0x03;
    //subpage = cdb[3];
//aka pf
    llbaa = (cdb[1] & 0x10) != 0;

    if (hdrsize == 6)
        allocation_len = cdb[4];
    else
        allocation_len = (cdb[7] << 8) | (cdb[8] << 0);

    /* As per SPC-4 an allocation length of 0 means no data transfer
     * so Just return good status now.
     */
    if (allocation_len == 0) {
        return(ocs_ramd_good_status(io));
    }

    /* Page control CHANGEABLE, not supported, return illegal request
     * invalid field in cdb (SPC-4, 6.11.3)
     */
    if (pc == MODE_SENSE_PC_CHANGEABLE) {
        ocs_log_info(NULL, "Mode Sense changeable not supported for LUN %d\n", io->tgt_io.lun);

        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    /* Page control SAVED, not supported, return illegal request
     * saving parameters not supported (SPC-4, 6.11.5)
     */
    if (pc == MODE_SENSE_PC_SAVED) {
        ocs_log_info(NULL, "Mode Sense saving parameters not supported for LUN %d\n", io->tgt_io.lun);
        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_SAVE_NOT_SUPPORTED, 0);
    }

    if ((page != MODE_SENSE_ALL_PAGES) && !tm_mode_page_supported(page)) {
        ocs_log_info(NULL, "Mode Sense (6) unsupported page code 0x%02x for LUN %d\n", page, io->tgt_io.lun);

        return ocs_ramd_check_cond(io, SNS_ILLEGAL_REQ, SNSCODE_INV_CDB, 0);
    }

    if (ocs_dma_alloc(io->ocs, &io->tgt_io.payload, 256, 16)) {
        ocs_log_err(NULL, "ocs_scsi_dma_alloc failed\n");
        return SCSI_HANDLER_NOT_STARTED;
    }
    ocs_assert(io->tgt_io.payload.virt, -1);

    /* build response data */
    mode_sense_len = tm_build_mode_parameter(io, page, dbd, llbaa, hdrsize, io->tgt_io.payload.virt, allocation_len);

    sgl[0].addr = io->tgt_io.payload.phys;
    sgl[0].len = mode_sense_len;

    io->tgt_io.is_read = TRUE;

    /* Send read data */
    if (ocs_scsi_send_rd_data(io, OCS_SCSI_LAST_DATAPHASE, NULL, sgl, 1, sgl[0].len, scsi_dataphase_cb, NULL) == 0) {
        rc = SCSI_HANDLER_DATAPHASE_STARTED;
    } else {
        rc = SCSI_HANDLER_NOT_STARTED;
    }
    return rc;
}