ceph/src/spdk/lib/scsi/task.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>.
   5  *   Copyright (c) Intel Corporation.
   6  *   All rights reserved.
   7  *
   8  *   Redistribution and use in source and binary forms, with or without
   9  *   modification, are permitted provided that the following conditions
  10  *   are met:
  11  *
  12  *     * Redistributions of source code must retain the above copyright
  13  *       notice, this list of conditions and the following disclaimer.
  14  *     * Redistributions in binary form must reproduce the above copyright
  15  *       notice, this list of conditions and the following disclaimer in
  16  *       the documentation and/or other materials provided with the
  17  *       distribution.
  18  *     * Neither the name of Intel Corporation nor the names of its
  19  *       contributors may be used to endorse or promote products derived
  20  *       from this software without specific prior written permission.
  21  *
  22  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include "scsi_internal.h"
  36 #include "spdk/endian.h"
  37 #include "spdk/env.h"
  38 #include "spdk/util.h"
  39
  40 static void
  41 spdk_scsi_task_free_data(struct spdk_scsi_task *task);
  42
  43 void
  44 spdk_scsi_task_put(struct spdk_scsi_task *task)
  45 {
  46         if (!task) {
  47                 return;
  48         }
  49
  50         task->ref--;
  51
  52         if (task->ref == 0) {
  53                 struct spdk_bdev_io *bdev_io = task->bdev_io;
  54
  55                 if (bdev_io) {
  56                         spdk_bdev_free_io(bdev_io);
  57                 }
  58
  59                 spdk_scsi_task_free_data(task);
  60
  61                 task->free_fn(task);
  62         }
  63 }
  64
  65 void
  66 spdk_scsi_task_construct(struct spdk_scsi_task *task,
  67                          spdk_scsi_task_cpl cpl_fn,
  68                          spdk_scsi_task_free free_fn)
  69 {
  70         assert(task != NULL);
  71         assert(cpl_fn != NULL);
  72         assert(free_fn != NULL);
  73
  74         task->cpl_fn = cpl_fn;
  75         task->free_fn = free_fn;
  76
  77         task->ref++;
  78
  79         /*
  80          * Pre-fill the iov_buffers to point to the embedded iov
  81          */
  82         assert(task->iov.iov_base == NULL);
  83         task->iovs = &task->iov;
  84         task->iovcnt = 1;
  85 }
  86
  87 static void
  88 spdk_scsi_task_free_data(struct spdk_scsi_task *task)
  89 {
  90         if (task->alloc_len != 0) {
  91                 spdk_dma_free(task->iov.iov_base);
  92                 task->alloc_len = 0;
  93         }
  94
  95         task->iov.iov_base = NULL;
  96         task->iov.iov_len = 0;
  97 }
  98
  99 static void *
 100 spdk_scsi_task_alloc_data(struct spdk_scsi_task *task, uint32_t alloc_len)
 101 {
 102         assert(task->alloc_len == 0);
 103
 104         task->iov.iov_base = spdk_dma_zmalloc(alloc_len, 0, NULL);
 105         task->iov.iov_len = alloc_len;
 106         task->alloc_len = alloc_len;
 107
 108         return task->iov.iov_base;
 109 }
 110
 111 int
 112 spdk_scsi_task_scatter_data(struct spdk_scsi_task *task, const void *src, size_t buf_len)
 113 {
 114         size_t len = 0;
 115         size_t buf_left = buf_len;
 116         int i;
 117         struct iovec *iovs = task->iovs;
 118         const uint8_t *pos;
 119
 120         if (buf_len == 0) {
 121                 return 0;
 122         }
 123
 124         if (task->iovcnt == 1 && iovs[0].iov_base == NULL) {
 125                 spdk_scsi_task_alloc_data(task, buf_len);
 126                 iovs[0] = task->iov;
 127         }
 128
 129         for (i = 0; i < task->iovcnt; i++) {
 130                 assert(iovs[i].iov_base != NULL);
 131                 len += iovs[i].iov_len;
 132         }
 133
 134         if (len < buf_len) {
 135                 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION,
 136                                           SPDK_SCSI_SENSE_ILLEGAL_REQUEST,
 137                                           SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB,
 138                                           SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
 139                 return -1;
 140         }
 141
 142         pos = src;
 143
 144         for (i = 0; i < task->iovcnt; i++) {
 145                 len = spdk_min(iovs[i].iov_len, buf_left);
 146                 buf_left -= len;
 147                 memcpy(iovs[i].iov_base, pos, len);
 148                 pos += len;
 149         }
 150
 151         return buf_len;
 152 }
 153
 154 void *
 155 spdk_scsi_task_gather_data(struct spdk_scsi_task *task, int *len)
 156 {
 157         int i;
 158         struct iovec *iovs = task->iovs;
 159         size_t buf_len = 0;
 160         uint8_t *buf, *pos;
 161
 162         for (i = 0; i < task->iovcnt; i++) {
 163                 assert(iovs[i].iov_base != NULL);
 164                 buf_len += iovs[i].iov_len;
 165         }
 166
 167         if (buf_len == 0) {
 168                 *len = 0;
 169                 return NULL;
 170         }
 171
 172         buf = spdk_dma_malloc(buf_len, 0, NULL);
 173         if (buf == NULL) {
 174                 *len = -1;
 175                 return NULL;
 176         }
 177
 178         pos = buf;
 179         for (i = 0; i < task->iovcnt; i++) {
 180                 memcpy(pos, iovs[i].iov_base, iovs[i].iov_len);
 181                 pos += iovs[i].iov_len;
 182         }
 183
 184         *len = buf_len;
 185         return buf;
 186 }
 187
 188 void
 189 spdk_scsi_task_set_data(struct spdk_scsi_task *task, void *data, uint32_t len)
 190 {
 191         assert(task->iovcnt == 1);
 192         assert(task->alloc_len == 0);
 193
 194         task->iovs[0].iov_base = data;
 195         task->iovs[0].iov_len = len;
 196 }
 197
 198 void
 199 spdk_scsi_task_build_sense_data(struct spdk_scsi_task *task, int sk, int asc, int ascq)
 200 {
 201         uint8_t *cp;
 202         int resp_code;
 203
 204         resp_code = 0x70; /* Current + Fixed format */
 205
 206         /* Sense Data */
 207         cp = task->sense_data;
 208
 209         /* VALID(7) RESPONSE CODE(6-0) */
 210         cp[0] = 0x80 | resp_code;
 211         /* Obsolete */
 212         cp[1] = 0;
 213         /* FILEMARK(7) EOM(6) ILI(5) SENSE KEY(3-0) */
 214         cp[2] = sk & 0xf;
 215         /* INFORMATION */
 216         memset(&cp[3], 0, 4);
 217
 218         /* ADDITIONAL SENSE LENGTH */
 219         cp[7] = 10;
 220
 221         /* COMMAND-SPECIFIC INFORMATION */
 222         memset(&cp[8], 0, 4);
 223         /* ADDITIONAL SENSE CODE */
 224         cp[12] = asc;
 225         /* ADDITIONAL SENSE CODE QUALIFIER */
 226         cp[13] = ascq;
 227         /* FIELD REPLACEABLE UNIT CODE */
 228         cp[14] = 0;
 229
 230         /* SKSV(7) SENSE KEY SPECIFIC(6-0,7-0,7-0) */
 231         cp[15] = 0;
 232         cp[16] = 0;
 233         cp[17] = 0;
 234
 235         /* SenseLength */
 236         task->sense_data_len = 18;
 237 }
 238
 239 void
 240 spdk_scsi_task_set_status(struct spdk_scsi_task *task, int sc, int sk,
 241                           int asc, int ascq)
 242 {
 243         if (sc == SPDK_SCSI_STATUS_CHECK_CONDITION) {
 244                 spdk_scsi_task_build_sense_data(task, sk, asc, ascq);
 245         }
 246         task->status = sc;
 247 }
 248
 249 void
 250 spdk_scsi_task_copy_status(struct spdk_scsi_task *dst,
 251                            struct spdk_scsi_task *src)
 252 {
 253         memcpy(dst->sense_data, src->sense_data, src->sense_data_len);
 254         dst->sense_data_len = src->sense_data_len;
 255         dst->status = src->status;
 256 }