tools/tools/vhba/rptluns/vhba_rptluns.c

   1 /*-
   2  * Copyright (c) 2010 by Panasas, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice immediately at the beginning of the file, without modification,
  10  *    this list of conditions, and the following disclaimer.
  11  * 2. The name of the author may not be used to endorse or promote products
  12  *    derived from this software without specific prior written permission.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  18  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26 /* $FreeBSD$ */
  27 /*
  28  * A VHBA device to test REPORT LUN functionality.
  29  */
  30 #include "vhba.h"
  31
  32 #define MAX_TGT         1
  33 #define MAX_LUN         1024
  34
  35 #define DISK_SIZE       32
  36 #define DISK_SHIFT      9
  37 #define DISK_NBLKS      ((DISK_SIZE << 20) >> DISK_SHIFT)
  38 #define PSEUDO_SPT      64
  39 #define PSEUDO_HDS      64
  40 #define PSEUDO_SPC      (PSEUDO_SPT * PSEUDO_HDS)
  41
  42 typedef struct {
  43         vhba_softc_t *  vhba;
  44         uint8_t *       disk;
  45         size_t          disk_size;
  46         struct task     qt;
  47         uint8_t         rpbitmap[MAX_LUN >> 3];
  48 } vhbarptluns_t;
  49
  50 static void vhba_task(void *, int);
  51 static void vhbarptluns_act(vhbarptluns_t *, struct ccb_scsiio *);
  52
  53 void
  54 vhba_init(vhba_softc_t *vhba)
  55 {
  56         static vhbarptluns_t vhbas;
  57         struct timeval now;
  58         int i;
  59
  60         vhbas.vhba = vhba;
  61         vhbas.disk_size = DISK_SIZE << 20;
  62         vhbas.disk = malloc(vhbas.disk_size, M_DEVBUF, M_WAITOK|M_ZERO);
  63         vhba->private = &vhbas;
  64         printf("setting luns");
  65         getmicrotime(&now);
  66         if (now.tv_usec & 0x1) {
  67                 vhbas.rpbitmap[0] |= 1;
  68         }
  69         for (i = 1; i < 8; i++) {
  70                 if (arc4random() & 1) {
  71                         printf(" %d", i);
  72                         vhbas.rpbitmap[0] |= (1 << i);
  73                 }
  74         }
  75         for (i = 8; i < MAX_LUN; i++) {
  76                 if ((arc4random() % i) == 0) {
  77                         vhbas.rpbitmap[i >> 3] |= (1 << (i & 0x7));
  78                         printf(" %d", i);
  79                 }
  80         }
  81         printf("\n");
  82         TASK_INIT(&vhbas.qt, 0, vhba_task, &vhbas);
  83 }
  84
  85 void
  86 vhba_fini(vhba_softc_t *vhba)
  87 {
  88         vhbarptluns_t *vhbas = vhba->private;
  89         vhba->private = NULL;
  90         free(vhbas->disk, M_DEVBUF);
  91 }
  92
  93 void
  94 vhba_kick(vhba_softc_t *vhba)
  95 {
  96         vhbarptluns_t *vhbas = vhba->private;
  97         taskqueue_enqueue(taskqueue_swi, &vhbas->qt);
  98 }
  99
 100 static void
 101 vhba_task(void *arg, int pending)
 102 {
 103         vhbarptluns_t *vhbas = arg;
 104         struct ccb_hdr *ccbh;
 105
 106         mtx_lock(&vhbas->vhba->lock);
 107         while ((ccbh = TAILQ_FIRST(&vhbas->vhba->actv)) != NULL) {
 108                 TAILQ_REMOVE(&vhbas->vhba->actv, ccbh, sim_links.tqe);
 109                 vhbarptluns_act(vhbas, (struct ccb_scsiio *)ccbh);
 110         }
 111         while ((ccbh = TAILQ_FIRST(&vhbas->vhba->done)) != NULL) {
 112                 TAILQ_REMOVE(&vhbas->vhba->done, ccbh, sim_links.tqe);
 113                 xpt_done((union ccb *)ccbh);
 114         }
 115         mtx_unlock(&vhbas->vhba->lock);
 116 }
 117
 118 static void
 119 vhbarptluns_act(vhbarptluns_t *vhbas, struct ccb_scsiio *csio)
 120 {
 121         char junk[128];
 122         uint8_t *cdb, *ptr, status;
 123         uint32_t data_len;
 124         uint64_t off;
 125         int i, attached_lun = 0;
 126
 127         data_len = 0;
 128         status = SCSI_STATUS_OK;
 129
 130         memset(&csio->sense_data, 0, sizeof (csio->sense_data));
 131         cdb = csio->cdb_io.cdb_bytes;
 132
 133         if (csio->ccb_h.target_id >= MAX_TGT) {
 134                 csio->ccb_h.status = CAM_SEL_TIMEOUT;
 135                 TAILQ_INSERT_TAIL(&vhbas->vhba->done, &csio->ccb_h, sim_links.tqe);
 136                 return;
 137         }
 138
 139         if (csio->ccb_h.target_lun < MAX_LUN) {
 140                 i = csio->ccb_h.target_lun & 0x7;
 141                 if (vhbas->rpbitmap[csio->ccb_h.target_lun >> 3] & (1 << i)) {
 142                         attached_lun = 1;
 143                 }
 144         }
 145         if (attached_lun == 0 && cdb[0] != INQUIRY && cdb[0] != REPORT_LUNS && cdb[0] != REQUEST_SENSE) {
 146                 vhba_fill_sense(csio, SSD_KEY_ILLEGAL_REQUEST, 0x25, 0x0);
 147                 TAILQ_INSERT_TAIL(&vhbas->vhba->done, &csio->ccb_h, sim_links.tqe);
 148                 return;
 149         }
 150
 151         switch (cdb[0]) {
 152         case MODE_SENSE:
 153         case MODE_SENSE_10:
 154         {
 155                 unsigned int nbyte;
 156                 uint8_t page = cdb[2] & SMS_PAGE_CODE;
 157                 uint8_t pgctl = cdb[2] & SMS_PAGE_CTRL_MASK;
 158
 159                 switch (page) {
 160                 case SMS_FORMAT_DEVICE_PAGE:
 161                 case SMS_GEOMETRY_PAGE:
 162                 case SMS_CACHE_PAGE:
 163                 case SMS_CONTROL_MODE_PAGE:
 164                 case SMS_ALL_PAGES_PAGE:
 165                         break;
 166                 default:
 167                         vhba_fill_sense(csio, SSD_KEY_ILLEGAL_REQUEST, 0x24, 0x0);
 168                         TAILQ_INSERT_TAIL(&vhbas->vhba->done, &csio->ccb_h, sim_links.tqe);
 169                         return;
 170                 }
 171                 memset(junk, 0, sizeof (junk));
 172                 if (cdb[1] & SMS_DBD) {
 173                         ptr = &junk[4];
 174                 } else {
 175                         ptr = junk;
 176                         ptr[3] = 8;
 177                         ptr[4] = ((1 << DISK_SHIFT) >> 24) & 0xff;
 178                         ptr[5] = ((1 << DISK_SHIFT) >> 16) & 0xff;
 179                         ptr[6] = ((1 << DISK_SHIFT) >>  8) & 0xff;
 180                         ptr[7] = ((1 << DISK_SHIFT)) & 0xff;
 181
 182                         ptr[8] = (DISK_NBLKS >> 24) & 0xff;
 183                         ptr[9] = (DISK_NBLKS >> 16) & 0xff;
 184                         ptr[10] = (DISK_NBLKS >> 8) & 0xff;
 185                         ptr[11] = DISK_NBLKS & 0xff;
 186                         ptr += 12;
 187                 }
 188
 189                 if (page == SMS_ALL_PAGES_PAGE || page == SMS_FORMAT_DEVICE_PAGE) {
 190                         ptr[0] = SMS_FORMAT_DEVICE_PAGE;
 191                         ptr[1] = 24;
 192                         if (pgctl != SMS_PAGE_CTRL_CHANGEABLE) {
 193                                 /* tracks per zone */
 194                                 /* ptr[2] = 0; */
 195                                 /* ptr[3] = 0; */
 196                                 /* alternate sectors per zone */
 197                                 /* ptr[4] = 0; */
 198                                 /* ptr[5] = 0; */
 199                                 /* alternate tracks per zone */
 200                                 /* ptr[6] = 0; */
 201                                 /* ptr[7] = 0; */
 202                                 /* alternate tracks per logical unit */
 203                                 /* ptr[8] = 0; */
 204                                 /* ptr[9] = 0; */
 205                                 /* sectors per track */
 206                                 ptr[10] = (PSEUDO_SPT >> 8) & 0xff;
 207                                 ptr[11] = PSEUDO_SPT & 0xff;
 208                                 /* data bytes per physical sector */
 209                                 ptr[12] = ((1 << DISK_SHIFT) >> 8) & 0xff;
 210                                 ptr[13] = (1 << DISK_SHIFT) & 0xff;
 211                                 /* interleave */
 212                                 /* ptr[14] = 0; */
 213                                 /* ptr[15] = 1; */
 214                                 /* track skew factor */
 215                                 /* ptr[16] = 0; */
 216                                 /* ptr[17] = 0; */
 217                                 /* cylinder skew factor */
 218                                 /* ptr[18] = 0; */
 219                                 /* ptr[19] = 0; */
 220                                 /* SSRC, HSEC, RMB, SURF */
 221                         }
 222                         ptr += 26;
 223                 }
 224
 225                 if (page == SMS_ALL_PAGES_PAGE || page == SMS_GEOMETRY_PAGE) {
 226                         ptr[0] = SMS_GEOMETRY_PAGE;
 227                         ptr[1] = 24;
 228                         if (pgctl != SMS_PAGE_CTRL_CHANGEABLE) {
 229                                 uint32_t cyl = (DISK_NBLKS + ((PSEUDO_SPC - 1))) / PSEUDO_SPC;
 230                                 /* number of cylinders */
 231                                 ptr[2] = (cyl >> 24) & 0xff;
 232                                 ptr[3] = (cyl >> 16) & 0xff;
 233                                 ptr[4] = cyl & 0xff;
 234                                 /* number of heads */
 235                                 ptr[5] = PSEUDO_HDS;
 236                                 /* starting cylinder- write precompensation */
 237                                 /* ptr[6] = 0; */
 238                                 /* ptr[7] = 0; */
 239                                 /* ptr[8] = 0; */
 240                                 /* starting cylinder- reduced write current */
 241                                 /* ptr[9] = 0; */
 242                                 /* ptr[10] = 0; */
 243                                 /* ptr[11] = 0; */
 244                                 /* drive step rate */
 245                                 /* ptr[12] = 0; */
 246                                 /* ptr[13] = 0; */
 247                                 /* landing zone cylinder */
 248                                 /* ptr[14] = 0; */
 249                                 /* ptr[15] = 0; */
 250                                 /* ptr[16] = 0; */
 251                                 /* RPL */
 252                                 /* ptr[17] = 0; */
 253                                 /* rotational offset */
 254                                 /* ptr[18] = 0; */
 255                                 /* medium rotation rate -  7200 RPM */
 256                                 ptr[20] = 0x1c;
 257                                 ptr[21] = 0x20;
 258                         }
 259                         ptr += 26;
 260                 }
 261
 262                 if (page == SMS_ALL_PAGES_PAGE || page == SMS_CACHE_PAGE) {
 263                         ptr[0] = SMS_CACHE_PAGE;
 264                         ptr[1] = 18;
 265                         ptr[2] = 1 << 2;
 266                         ptr += 20;
 267                 }
 268
 269                 if (page == SMS_ALL_PAGES_PAGE || page == SMS_CONTROL_MODE_PAGE) {
 270                         ptr[0] = SMS_CONTROL_MODE_PAGE;
 271                         ptr[1] = 10;
 272                         if (pgctl != SMS_PAGE_CTRL_CHANGEABLE) {
 273                                 ptr[3] = 1 << 4; /* unrestricted reordering allowed */
 274                                 ptr[8] = 0x75;   /* 30000 ms */
 275                                 ptr[9] = 0x30;
 276                         }
 277                         ptr += 12;
 278                 }
 279                 nbyte = (char *)ptr - &junk[0];
 280                 ptr[0] = nbyte - 4;
 281
 282                 if (cdb[0] == MODE_SENSE) {
 283                         data_len = min(cdb[4], csio->dxfer_len);
 284                 } else {
 285                         uint16_t tw = (cdb[7] << 8) | cdb[8];
 286                         data_len = min(tw, csio->dxfer_len);
 287                 }
 288                 data_len = min(data_len, nbyte);
 289                 if (data_len) {
 290                         memcpy(csio->data_ptr, junk, data_len);
 291                 }
 292                 csio->resid = csio->dxfer_len - data_len;
 293                 break;
 294         }
 295         case READ_6:
 296         case READ_10:
 297         case READ_12:
 298         case READ_16:
 299         case WRITE_6:
 300         case WRITE_10:
 301         case WRITE_12:
 302         case WRITE_16:
 303                 if (vhba_rwparm(cdb, &off, &data_len, DISK_NBLKS, DISK_SHIFT)) {
 304                         vhba_fill_sense(csio, SSD_KEY_ILLEGAL_REQUEST, 0x24, 0x0);
 305                         break;
 306                 }
 307                 if (data_len) {
 308                         if ((cdb[0] & 0xf) == 8) {
 309                                 memcpy(csio->data_ptr, &vhbas->disk[off], data_len);
 310                         } else {
 311                                 memcpy(&vhbas->disk[off], csio->data_ptr, data_len);
 312                         }
 313                         csio->resid = csio->dxfer_len - data_len;
 314                 } else {
 315                         csio->resid = csio->dxfer_len;
 316                 }
 317                 break;
 318                 break;
 319
 320         case READ_CAPACITY:
 321                 if (cdb[2] || cdb[3] || cdb[4] || cdb[5]) {
 322                         vhba_fill_sense(csio, SSD_KEY_UNIT_ATTENTION, 0x24, 0x0);
 323                         break;
 324                 }
 325                 if (cdb[8] & 0x1) { /* PMI */
 326                         csio->data_ptr[0] = 0xff;
 327                         csio->data_ptr[1] = 0xff;
 328                         csio->data_ptr[2] = 0xff;
 329                         csio->data_ptr[3] = 0xff;
 330                 } else {
 331                         uint64_t last_blk = DISK_NBLKS - 1;
 332                         if (last_blk < 0xffffffffULL) {
 333                             csio->data_ptr[0] = (last_blk >> 24) & 0xff;
 334                             csio->data_ptr[1] = (last_blk >> 16) & 0xff;
 335                             csio->data_ptr[2] = (last_blk >>  8) & 0xff;
 336                             csio->data_ptr[3] = (last_blk) & 0xff;
 337                         } else {
 338                             csio->data_ptr[0] = 0xff;
 339                             csio->data_ptr[1] = 0xff;
 340                             csio->data_ptr[2] = 0xff;
 341                             csio->data_ptr[3] = 0xff;
 342                         }
 343                 }
 344                 csio->data_ptr[4] = ((1 << DISK_SHIFT) >> 24) & 0xff;
 345                 csio->data_ptr[5] = ((1 << DISK_SHIFT) >> 16) & 0xff;
 346                 csio->data_ptr[6] = ((1 << DISK_SHIFT) >>  8) & 0xff;
 347                 csio->data_ptr[7] = ((1 << DISK_SHIFT)) & 0xff;
 348                 break;
 349
 350         default:
 351                 vhba_default_cmd(csio, MAX_LUN, vhbas->rpbitmap);
 352                 break;
 353         }
 354         csio->ccb_h.status &= ~CAM_STATUS_MASK;
 355         if (csio->scsi_status != SCSI_STATUS_OK) {
 356                 csio->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
 357                 if (csio->scsi_status == SCSI_STATUS_CHECK_COND) {
 358                         csio->ccb_h.status |= CAM_AUTOSNS_VALID;
 359                 }
 360         } else {
 361                 csio->scsi_status = SCSI_STATUS_OK;
 362                 csio->ccb_h.status |= CAM_REQ_CMP;
 363         }
 364         TAILQ_INSERT_TAIL(&vhbas->vhba->done, &csio->ccb_h, sim_links.tqe);
 365 }
 366 DEV_MODULE(vhba_rtpluns, vhba_modprobe, NULL);