share/examples/scsi_target/scsi_cmds.c

   1 /*
   2  * SCSI Disk Emulator
   3  *
   4  * Copyright (c) 2002 Nate Lawson.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions, and the following disclaimer,
  12  *    without modification, immediately at the beginning of the file.
  13  * 2. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #include <stdio.h>
  32 #include <stddef.h>
  33 #include <stdarg.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <err.h>
  37 #include <aio.h>
  38 #include <unistd.h>
  39 #include <assert.h>
  40 #include <sys/param.h>
  41 #include <sys/types.h>
  42
  43 #include <cam/cam.h>
  44 #include <cam/cam_ccb.h>
  45 #include <cam/scsi/scsi_all.h>
  46 #include <cam/scsi/scsi_targetio.h>
  47 #include "scsi_target.h"
  48
  49 typedef int targ_start_func(struct ccb_accept_tio *, struct ccb_scsiio *);
  50 typedef void targ_done_func(struct ccb_accept_tio *, struct ccb_scsiio *,
  51                               io_ops);
  52 #ifndef REPORT_LUNS
  53 #define REPORT_LUNS     0xa0
  54 #endif
  55
  56 struct targ_cdb_handlers {
  57         u_int8_t          cmd;
  58         targ_start_func  *start;
  59         targ_done_func   *done;
  60 #define ILLEGAL_CDB       0xFF
  61 };
  62
  63 static targ_start_func          tcmd_inquiry;
  64 static targ_start_func          tcmd_req_sense;
  65 static targ_start_func          tcmd_rd_cap;
  66 #ifdef READ_16
  67 static targ_start_func          tcmd_rd_cap16;
  68 #endif
  69 static targ_start_func          tcmd_rdwr;
  70 static targ_start_func          tcmd_rdwr_decode;
  71 static targ_done_func           tcmd_rdwr_done;
  72 static targ_start_func          tcmd_null_ok;
  73 static targ_start_func          tcmd_illegal_req;
  74 static int                      start_io(struct ccb_accept_tio *atio,
  75                                          struct ccb_scsiio *ctio, int dir);
  76 static int init_inquiry(u_int16_t req_flags, u_int16_t sim_flags);
  77 static struct initiator_state *
  78                         tcmd_get_istate(u_int init_id);
  79 static void cdb_debug(u_int8_t *cdb, const char *msg, ...);
  80
  81 static struct targ_cdb_handlers cdb_handlers[] = {
  82         { READ_10,              tcmd_rdwr,              tcmd_rdwr_done },
  83         { WRITE_10,             tcmd_rdwr,              tcmd_rdwr_done },
  84         { READ_6,               tcmd_rdwr,              tcmd_rdwr_done },
  85         { WRITE_6,              tcmd_rdwr,              tcmd_rdwr_done },
  86         { INQUIRY,              tcmd_inquiry,           NULL },
  87         { REQUEST_SENSE,        tcmd_req_sense,         NULL },
  88         { READ_CAPACITY,        tcmd_rd_cap,            NULL },
  89         { TEST_UNIT_READY,      tcmd_null_ok,           NULL },
  90         { START_STOP_UNIT,      tcmd_null_ok,           NULL },
  91         { SYNCHRONIZE_CACHE,    tcmd_null_ok,           NULL },
  92         { MODE_SENSE_6,         tcmd_illegal_req,       NULL },
  93         { MODE_SELECT_6,        tcmd_illegal_req,       NULL },
  94         { REPORT_LUNS,          tcmd_illegal_req,       NULL },
  95 #ifdef READ_16
  96         { READ_16,              tcmd_rdwr,              tcmd_rdwr_done },
  97         { WRITE_16,             tcmd_rdwr,              tcmd_rdwr_done },
  98         { SERVICE_ACTION_IN,    tcmd_rd_cap16,          NULL },
  99 #endif
 100         { ILLEGAL_CDB,          NULL,                   NULL }
 101 };
 102
 103 static struct scsi_inquiry_data inq_data;
 104 static struct initiator_state istates[MAX_INITIATORS];
 105 extern int              debug;
 106 extern off_t            volume_size;
 107 extern u_int            sector_size;
 108 extern size_t           buf_size;
 109
 110 cam_status
 111 tcmd_init(u_int16_t req_inq_flags, u_int16_t sim_inq_flags)
 112 {
 113         struct initiator_state *istate;
 114         int i, ret;
 115
 116         /* Initialize our inquiry data */
 117         ret = init_inquiry(req_inq_flags, sim_inq_flags);
 118         if (ret != 0)
 119                 return (ret);
 120
 121         /* We start out life with a UA to indicate power-on/reset. */
 122         for (i = 0; i < MAX_INITIATORS; i++) {
 123                 istate = tcmd_get_istate(i);
 124                 bzero(istate, sizeof(*istate));
 125                 istate->pending_ua = UA_POWER_ON;
 126         }
 127
 128         return (0);
 129 }
 130
 131 /* Caller allocates CTIO, sets its init_id
 132 return 0 if done, 1 if more processing needed
 133 on 0, caller sets SEND_STATUS */
 134 int
 135 tcmd_handle(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio, io_ops event)
 136 {
 137         static struct targ_cdb_handlers *last_cmd;
 138         struct initiator_state *istate;
 139         struct atio_descr *a_descr;
 140         int ret;
 141
 142         if (debug) {
 143                 warnx("tcmd_handle atio %p ctio %p atioflags %#x", atio, ctio,
 144                       atio->ccb_h.flags);
 145         }
 146         ret = 0;
 147         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 148
 149         /* Do a full lookup if one-behind cache failed */
 150         if (last_cmd == NULL || last_cmd->cmd != a_descr->cdb[0]) {
 151                 struct targ_cdb_handlers *h;
 152
 153                 for (h = cdb_handlers; h->cmd != ILLEGAL_CDB; h++) {
 154                         if (a_descr->cdb[0] == h->cmd)
 155                                 break;
 156                 }
 157                 last_cmd = h;
 158         }
 159
 160         /* call completion and exit */
 161         if (event != ATIO_WORK) {
 162                 if (last_cmd->done != NULL)
 163                         last_cmd->done(atio, ctio, event);
 164                 else
 165                         free_ccb((union ccb *)ctio);
 166                 return (1);
 167         }
 168
 169         if (last_cmd->cmd == ILLEGAL_CDB) {
 170                 if (event != ATIO_WORK) {
 171                         warnx("no done func for %#x???", a_descr->cdb[0]);
 172                         abort();
 173                 }
 174                 /* Not found, return illegal request */
 175                 warnx("cdb %#x not handled", a_descr->cdb[0]);
 176                 tcmd_illegal_req(atio, ctio);
 177                 send_ccb((union ccb *)ctio, /*priority*/1);
 178                 return (0);
 179         }
 180
 181         istate = tcmd_get_istate(ctio->init_id);
 182         if (istate == NULL) {
 183                 tcmd_illegal_req(atio, ctio);
 184                 send_ccb((union ccb *)ctio, /*priority*/1);
 185                 return (0);
 186         }
 187
 188         if (istate->pending_ca == 0 && istate->pending_ua != 0 &&
 189             a_descr->cdb[0] != INQUIRY) {
 190                 tcmd_sense(ctio->init_id, ctio, SSD_KEY_UNIT_ATTENTION,
 191                            0x29, istate->pending_ua == UA_POWER_ON ? 1 : 2);
 192                 istate->pending_ca = CA_UNIT_ATTN;
 193                 if (debug) {
 194                         cdb_debug(a_descr->cdb, "UA active for %u: ",
 195                                   atio->init_id);
 196                 }
 197                 send_ccb((union ccb *)ctio, /*priority*/1);
 198                 return (0);
 199         }
 200
 201         /* Store current CA and UA for later */
 202         istate->orig_ua = istate->pending_ua;
 203         istate->orig_ca = istate->pending_ca;
 204
 205         /*
 206          * As per SAM2, any command that occurs
 207          * after a CA is reported, clears the CA.  We must
 208          * also clear the UA condition, if any, that caused
 209          * the CA to occur assuming the UA is not for a
 210          * persistent condition.
 211          */
 212         istate->pending_ca = CA_NONE;
 213         if (istate->orig_ca == CA_UNIT_ATTN)
 214                 istate->pending_ua = UA_NONE;
 215
 216         /* If we have a valid handler, call start or completion function */
 217         if (last_cmd->cmd != ILLEGAL_CDB) {
 218                 ret = last_cmd->start(atio, ctio);
 219                 /* XXX hack */
 220                 if (last_cmd->start != tcmd_rdwr) {
 221                         a_descr->init_req += ctio->dxfer_len;
 222                         send_ccb((union ccb *)ctio, /*priority*/1);
 223                 }
 224         }
 225
 226         return (ret);
 227 }
 228
 229 static struct initiator_state *
 230 tcmd_get_istate(u_int init_id)
 231 {
 232         if (init_id >= MAX_INITIATORS) {
 233                 warnx("illegal init_id %d, max %d", init_id, MAX_INITIATORS - 1);
 234                 return (NULL);
 235         } else {
 236                 return (&istates[init_id]);
 237         }
 238 }
 239
 240 void
 241 tcmd_sense(u_int init_id, struct ccb_scsiio *ctio, u_int8_t flags,
 242                u_int8_t asc, u_int8_t ascq)
 243 {
 244         struct initiator_state *istate;
 245         struct scsi_sense_data_fixed *sense;
 246
 247         /* Set our initiator's istate */
 248         istate = tcmd_get_istate(init_id);
 249         if (istate == NULL)
 250                 return;
 251         istate->pending_ca |= CA_CMD_SENSE; /* XXX set instead of or? */
 252         sense = (struct scsi_sense_data_fixed *)&istate->sense_data;
 253         bzero(sense, sizeof(*sense));
 254         sense->error_code = SSD_CURRENT_ERROR;
 255         sense->flags = flags;
 256         sense->add_sense_code = asc;
 257         sense->add_sense_code_qual = ascq;
 258         sense->extra_len =
 259                 offsetof(struct scsi_sense_data_fixed, sense_key_spec[2]) -
 260                 offsetof(struct scsi_sense_data_fixed, extra_len);
 261
 262         /* Fill out the supplied CTIO */
 263         if (ctio != NULL) {
 264                 bcopy(sense, &ctio->sense_data, sizeof(*sense));
 265                 ctio->sense_len = sizeof(*sense);  /* XXX */
 266                 ctio->ccb_h.flags &= ~CAM_DIR_MASK;
 267                 ctio->ccb_h.flags |= CAM_DIR_NONE | CAM_SEND_SENSE |
 268                                      CAM_SEND_STATUS;
 269                 ctio->dxfer_len = 0;
 270                 ctio->scsi_status = SCSI_STATUS_CHECK_COND;
 271         }
 272 }
 273
 274 void
 275 tcmd_ua(u_int init_id, ua_types new_ua)
 276 {
 277         struct initiator_state *istate;
 278         u_int start, end;
 279
 280         if (init_id == CAM_TARGET_WILDCARD) {
 281                 start = 0;
 282                 end = MAX_INITIATORS - 1;
 283         } else {
 284                 start = end = init_id;
 285         }
 286
 287         for (; start <= end; start++) {
 288                 istate = tcmd_get_istate(start);
 289                 if (istate == NULL)
 290                         break;
 291                 istate->pending_ua = new_ua;
 292         }
 293 }
 294
 295 static int
 296 tcmd_inquiry(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 297 {
 298         struct scsi_inquiry *inq;
 299         struct atio_descr *a_descr;
 300         struct initiator_state *istate;
 301         struct scsi_sense_data_fixed *sense;
 302
 303         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 304         inq = (struct scsi_inquiry *)a_descr->cdb;
 305
 306         if (debug)
 307                 cdb_debug(a_descr->cdb, "INQUIRY from %u: ", atio->init_id);
 308         /*
 309          * Validate the command.  We don't support any VPD pages, so
 310          * complain if EVPD or CMDDT is set.
 311          */
 312         istate = tcmd_get_istate(ctio->init_id);
 313         sense = (struct scsi_sense_data_fixed *)&istate->sense_data;
 314         if ((inq->byte2 & SI_EVPD) != 0) {
 315                 tcmd_illegal_req(atio, ctio);
 316                 sense->sense_key_spec[0] = SSD_SCS_VALID | SSD_FIELDPTR_CMD |
 317                         SSD_BITPTR_VALID | /*bit value*/1;
 318                 sense->sense_key_spec[1] = 0;
 319                 sense->sense_key_spec[2] =
 320                         offsetof(struct scsi_inquiry, byte2);
 321         } else if (inq->page_code != 0) {
 322                 tcmd_illegal_req(atio, ctio);
 323                 sense->sense_key_spec[0] = SSD_SCS_VALID | SSD_FIELDPTR_CMD;
 324                 sense->sense_key_spec[1] = 0;
 325                 sense->sense_key_spec[2] =
 326                         offsetof(struct scsi_inquiry, page_code);
 327         } else {
 328                 bcopy(&inq_data, ctio->data_ptr, sizeof(inq_data));
 329                 ctio->dxfer_len = inq_data.additional_length + 4;
 330                 ctio->dxfer_len = min(ctio->dxfer_len,
 331                                       scsi_2btoul(inq->length));
 332                 ctio->ccb_h.flags |= CAM_DIR_IN | CAM_SEND_STATUS;
 333                 ctio->scsi_status = SCSI_STATUS_OK;
 334         }
 335         return (0);
 336 }
 337
 338 /* Initialize the inquiry response structure with the requested flags */
 339 static int
 340 init_inquiry(u_int16_t req_flags, u_int16_t sim_flags)
 341 {
 342         struct scsi_inquiry_data *inq;
 343
 344         inq = &inq_data;
 345         bzero(inq, sizeof(*inq));
 346         inq->device = T_DIRECT | (SID_QUAL_LU_CONNECTED << 5);
 347 #ifdef SCSI_REV_SPC
 348         inq->version = SCSI_REV_SPC; /* was 2 */
 349 #else
 350         inq->version = SCSI_REV_3; /* was 2 */
 351 #endif
 352
 353         /*
 354          * XXX cpi.hba_inquiry doesn't support Addr16 so we give the
 355          * user what they want if they ask for it.
 356          */
 357         if ((req_flags & SID_Addr16) != 0) {
 358                 sim_flags |= SID_Addr16;
 359                 warnx("Not sure SIM supports Addr16 but enabling it anyway");
 360         }
 361
 362         /* Advertise only what the SIM can actually support */
 363         req_flags &= sim_flags;
 364         scsi_ulto2b(req_flags, &inq->spc2_flags);
 365
 366         inq->response_format = 2; /* SCSI2 Inquiry Format */
 367         inq->additional_length = SHORT_INQUIRY_LENGTH -
 368                 offsetof(struct scsi_inquiry_data, additional_length);
 369         bcopy("FreeBSD ", inq->vendor, SID_VENDOR_SIZE);
 370         bcopy("Emulated Disk   ", inq->product, SID_PRODUCT_SIZE);
 371         bcopy("0.1 ", inq->revision, SID_REVISION_SIZE);
 372         return (0);
 373 }
 374
 375 static int
 376 tcmd_req_sense(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 377 {
 378         struct scsi_request_sense *rsense;
 379         struct scsi_sense_data_fixed *sense;
 380         struct initiator_state *istate;
 381         size_t dlen;
 382         struct atio_descr *a_descr;
 383
 384         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 385         rsense = (struct scsi_request_sense *)a_descr->cdb;
 386
 387         istate = tcmd_get_istate(ctio->init_id);
 388         sense = (struct scsi_sense_data_fixed *)&istate->sense_data;
 389
 390         if (debug) {
 391                 cdb_debug(a_descr->cdb, "REQ SENSE from %u: ", atio->init_id);
 392                 warnx("Sending sense: %#x %#x %#x", sense->flags,
 393                       sense->add_sense_code, sense->add_sense_code_qual);
 394         }
 395
 396         if (istate->orig_ca == 0) {
 397                 tcmd_sense(ctio->init_id, NULL, SSD_KEY_NO_SENSE, 0, 0);
 398                 warnx("REQUEST SENSE from %u but no pending CA!",
 399                       ctio->init_id);
 400         }
 401
 402         bcopy(sense, ctio->data_ptr, sizeof(struct scsi_sense_data));
 403         dlen = offsetof(struct scsi_sense_data_fixed, extra_len) +
 404                         sense->extra_len + 1;
 405         ctio->dxfer_len = min(dlen, SCSI_CDB6_LEN(rsense->length));
 406         ctio->ccb_h.flags |= CAM_DIR_IN | CAM_SEND_STATUS;
 407         ctio->scsi_status = SCSI_STATUS_OK;
 408         return (0);
 409 }
 410
 411 static int
 412 tcmd_rd_cap(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 413 {
 414         struct scsi_read_capacity_data *srp;
 415         struct atio_descr *a_descr;
 416         uint32_t vsize;
 417
 418         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 419         srp = (struct scsi_read_capacity_data *)ctio->data_ptr;
 420
 421         if (volume_size > 0xffffffff)
 422                 vsize = 0xffffffff;
 423         else
 424                 vsize = (uint32_t)(volume_size - 1);
 425
 426         if (debug) {
 427                 cdb_debug(a_descr->cdb, "READ CAP from %u (%u, %u): ",
 428                           atio->init_id, vsize, sector_size);
 429         }
 430
 431         bzero(srp, sizeof(*srp));
 432         scsi_ulto4b(vsize, srp->addr);
 433         scsi_ulto4b(sector_size, srp->length);
 434
 435         ctio->dxfer_len = sizeof(*srp);
 436         ctio->ccb_h.flags |= CAM_DIR_IN | CAM_SEND_STATUS;
 437         ctio->scsi_status = SCSI_STATUS_OK;
 438         return (0);
 439 }
 440
 441 #ifdef READ_16
 442 static int
 443 tcmd_rd_cap16(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 444 {
 445         struct scsi_read_capacity_16 *scsi_cmd;
 446         struct scsi_read_capacity_data_long *srp;
 447         struct atio_descr *a_descr;
 448
 449         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 450         scsi_cmd = (struct scsi_read_capacity_16 *)a_descr->cdb;
 451         srp = (struct scsi_read_capacity_data_long *)ctio->data_ptr;
 452
 453         if (scsi_cmd->service_action != SRC16_SERVICE_ACTION) {
 454                 tcmd_illegal_req(atio, ctio);
 455                 return (0);
 456         }
 457
 458         if (debug) {
 459                 cdb_debug(a_descr->cdb, "READ CAP16 from %u (%u, %u): ",
 460                           atio->init_id, volume_size - 1, sector_size);
 461         }
 462
 463         bzero(srp, sizeof(*srp));
 464         scsi_u64to8b(volume_size - 1, srp->addr);
 465         scsi_ulto4b(sector_size, srp->length);
 466
 467         ctio->dxfer_len = sizeof(*srp);
 468         ctio->ccb_h.flags |= CAM_DIR_IN | CAM_SEND_STATUS;
 469         ctio->scsi_status = SCSI_STATUS_OK;
 470         return (0);
 471 }
 472 #endif
 473
 474 static int
 475 tcmd_rdwr(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 476 {
 477         struct atio_descr *a_descr;
 478         struct ctio_descr *c_descr;
 479         int ret;
 480
 481         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 482         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
 483
 484         /* Command needs to be decoded */
 485         if ((a_descr->flags & CAM_DIR_MASK) == CAM_DIR_BOTH) {
 486                 if (debug)
 487                         warnx("Calling rdwr_decode");
 488                 ret = tcmd_rdwr_decode(atio, ctio);
 489                 if (ret == 0) {
 490                         send_ccb((union ccb *)ctio, /*priority*/1);
 491                         return (0);
 492                 }
 493         }
 494         ctio->ccb_h.flags |= a_descr->flags;
 495
 496         /* Call appropriate work function */
 497         if ((a_descr->flags & CAM_DIR_IN) != 0) {
 498                 ret = start_io(atio, ctio, CAM_DIR_IN);
 499                 if (debug)
 500                         warnx("Starting %p DIR_IN @" OFF_FMT ":%u",
 501                             a_descr, c_descr->offset, a_descr->targ_req);
 502         } else {
 503                 ret = start_io(atio, ctio, CAM_DIR_OUT);
 504                 if (debug)
 505                         warnx("Starting %p DIR_OUT @" OFF_FMT ":%u",
 506                             a_descr, c_descr->offset, a_descr->init_req);
 507         }
 508
 509         return (ret);
 510 }
 511
 512 static int
 513 tcmd_rdwr_decode(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 514 {
 515         uint64_t blkno;
 516         uint32_t count;
 517         struct atio_descr *a_descr;
 518         u_int8_t *cdb;
 519
 520         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 521         cdb = a_descr->cdb;
 522         if (debug)
 523                 cdb_debug(cdb, "R/W from %u: ", atio->init_id);
 524
 525         switch (cdb[0]) {
 526         case READ_6:
 527         case WRITE_6:
 528         {
 529                 struct scsi_rw_6 *rw_6 = (struct scsi_rw_6 *)cdb;
 530                 blkno = scsi_3btoul(rw_6->addr);
 531                 count = rw_6->length;
 532                 break;
 533         }
 534         case READ_10:
 535         case WRITE_10:
 536         {
 537                 struct scsi_rw_10 *rw_10 = (struct scsi_rw_10 *)cdb;
 538                 blkno = scsi_4btoul(rw_10->addr);
 539                 count = scsi_2btoul(rw_10->length);
 540                 break;
 541         }
 542 #ifdef READ_16
 543         case READ_16:
 544         case WRITE_16:
 545         {
 546                 struct scsi_rw_16 *rw_16 = (struct scsi_rw_16 *)cdb;
 547                 blkno = scsi_8btou64(rw_16->addr);
 548                 count = scsi_4btoul(rw_16->length);
 549                 break;
 550         }
 551 #endif
 552         default:
 553                 tcmd_illegal_req(atio, ctio);
 554                 return (0);
 555         }
 556         if (blkno + count > volume_size) {
 557                 warnx("Attempt to access past end of volume");
 558                 tcmd_sense(ctio->init_id, ctio,
 559                            SSD_KEY_ILLEGAL_REQUEST, 0x21, 0);
 560                 return (0);
 561         }
 562
 563         /* Get an (overall) data length and set direction */
 564         a_descr->base_off = ((off_t)blkno) * sector_size;
 565         a_descr->total_len = count * sector_size;
 566         if (a_descr->total_len == 0) {
 567                 if (debug)
 568                         warnx("r/w 0 blocks @ blkno " OFF_FMT, blkno);
 569                 tcmd_null_ok(atio, ctio);
 570                 return (0);
 571         } else if (cdb[0] == WRITE_6 || cdb[0] == WRITE_10) {
 572                 a_descr->flags |= CAM_DIR_OUT;
 573                 if (debug)
 574                         warnx("write %u blocks @ blkno " OFF_FMT, count, blkno);
 575         } else {
 576                 a_descr->flags |= CAM_DIR_IN;
 577                 if (debug)
 578                         warnx("read %u blocks @ blkno " OFF_FMT,  count, blkno);
 579         }
 580         return (1);
 581 }
 582
 583 static int
 584 start_io(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio, int dir)
 585 {
 586         struct atio_descr *a_descr;
 587         struct ctio_descr *c_descr;
 588         int ret;
 589
 590         /* Set up common structures */
 591         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 592         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
 593
 594         if (dir == CAM_DIR_IN) {
 595                 c_descr->offset = a_descr->base_off + a_descr->targ_req;
 596                 ctio->dxfer_len = a_descr->total_len - a_descr->targ_req;
 597         } else {
 598                 c_descr->offset = a_descr->base_off + a_descr->init_req;
 599                 ctio->dxfer_len = a_descr->total_len - a_descr->init_req;
 600         }
 601         ctio->dxfer_len = min(ctio->dxfer_len, buf_size);
 602         assert(ctio->dxfer_len >= 0);
 603
 604         c_descr->aiocb.aio_offset = c_descr->offset;
 605         c_descr->aiocb.aio_nbytes = ctio->dxfer_len;
 606
 607         /* If DIR_IN, start read from target, otherwise begin CTIO xfer. */
 608         ret = 1;
 609         if (dir == CAM_DIR_IN) {
 610                 if (notaio) {
 611                         if (debug)
 612                                 warnx("read sync %lu @ block " OFF_FMT,
 613                                     (unsigned long)
 614                                     (ctio->dxfer_len / sector_size),
 615                                     c_descr->offset / sector_size);
 616                         if (lseek(c_descr->aiocb.aio_fildes,
 617                             c_descr->aiocb.aio_offset, SEEK_SET) < 0) {
 618                                 perror("lseek");
 619                                 err(1, "lseek");
 620                         }
 621                         if (read(c_descr->aiocb.aio_fildes,
 622                             (void *)c_descr->aiocb.aio_buf,
 623                             ctio->dxfer_len) != ctio->dxfer_len) {
 624                                 err(1, "read");
 625                         }
 626                 } else {
 627                         if (debug)
 628                                 warnx("read async %lu @ block " OFF_FMT,
 629                                     (unsigned long)
 630                                     (ctio->dxfer_len / sector_size),
 631                                     c_descr->offset / sector_size);
 632                         if (aio_read(&c_descr->aiocb) < 0) {
 633                                 err(1, "aio_read"); /* XXX */
 634                         }
 635                 }
 636                 a_descr->targ_req += ctio->dxfer_len;
 637                 /* if we're done, we can mark the CCB as to send status */
 638                 if (a_descr->targ_req == a_descr->total_len) {
 639                         ctio->ccb_h.flags |= CAM_SEND_STATUS;
 640                         ctio->scsi_status = SCSI_STATUS_OK;
 641                         ret = 0;
 642                 }
 643                 if (notaio)
 644                         tcmd_rdwr_done(atio, ctio, AIO_DONE);
 645         } else {
 646                 if (a_descr->targ_ack == a_descr->total_len)
 647                         tcmd_null_ok(atio, ctio);
 648                 a_descr->init_req += ctio->dxfer_len;
 649                 if (a_descr->init_req == a_descr->total_len &&
 650                     ctio->dxfer_len > 0) {
 651                         /*
 652                          * If data phase done, remove atio from workq.
 653                          * The completion handler will call work_atio to
 654                          * send the final status.
 655                          */
 656                         ret = 0;
 657                 }
 658                 send_ccb((union ccb *)ctio, /*priority*/1);
 659         }
 660
 661         return (ret);
 662 }
 663
 664 static void
 665 tcmd_rdwr_done(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio,
 666                io_ops event)
 667 {
 668         struct atio_descr *a_descr;
 669         struct ctio_descr *c_descr;
 670
 671         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 672         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
 673
 674         switch (event) {
 675         case AIO_DONE:
 676                 if (!notaio && aio_return(&c_descr->aiocb) < 0) {
 677                         warn("aio_return error");
 678                         /* XXX */
 679                         tcmd_sense(ctio->init_id, ctio,
 680                                    SSD_KEY_MEDIUM_ERROR, 0, 0);
 681                         send_ccb((union ccb *)ctio, /*priority*/1);
 682                         break;
 683                 }
 684                 a_descr->targ_ack += ctio->dxfer_len;
 685                 if ((a_descr->flags & CAM_DIR_IN) != 0) {
 686                         if (debug) {
 687                                 if (notaio)
 688                                         warnx("sending CTIO for AIO read");
 689                                 else
 690                                         warnx("sending CTIO for sync read");
 691                         }
 692                         a_descr->init_req += ctio->dxfer_len;
 693                         send_ccb((union ccb *)ctio, /*priority*/1);
 694                 } else {
 695                         /* Use work function to send final status */
 696                         if (a_descr->init_req == a_descr->total_len)
 697                                 work_atio(atio);
 698                         if (debug)
 699                                 warnx("AIO done freeing CTIO");
 700                         free_ccb((union ccb *)ctio);
 701                 }
 702                 break;
 703         case CTIO_DONE:
 704                 switch (ctio->ccb_h.status & CAM_STATUS_MASK) {
 705                 case CAM_REQ_CMP:
 706                         break;
 707                 case CAM_REQUEUE_REQ:
 708                         warnx("requeueing request");
 709                         if ((a_descr->flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
 710                                 if (aio_write(&c_descr->aiocb) < 0) {
 711                                         err(1, "aio_write"); /* XXX */
 712                                 }
 713                         } else {
 714                                 if (aio_read(&c_descr->aiocb) < 0) {
 715                                         err(1, "aio_read"); /* XXX */
 716                                 }
 717                         }
 718                         return;
 719                 default:
 720                         errx(1, "CTIO failed, status %#x", ctio->ccb_h.status);
 721                 }
 722                 a_descr->init_ack += ctio->dxfer_len;
 723                 if ((a_descr->flags & CAM_DIR_MASK) == CAM_DIR_OUT &&
 724                     ctio->dxfer_len > 0) {
 725                         a_descr->targ_req += ctio->dxfer_len;
 726                         if (notaio) {
 727                                 if (debug)
 728                                         warnx("write sync %lu @ block "
 729                                             OFF_FMT, (unsigned long)
 730                                             (ctio->dxfer_len / sector_size),
 731                                             c_descr->offset / sector_size);
 732                                 if (lseek(c_descr->aiocb.aio_fildes,
 733                                     c_descr->aiocb.aio_offset, SEEK_SET) < 0) {
 734                                         perror("lseek");
 735                                         err(1, "lseek");
 736                                 }
 737                                 if (write(c_descr->aiocb.aio_fildes,
 738                                     (void *) c_descr->aiocb.aio_buf,
 739                                     ctio->dxfer_len) != ctio->dxfer_len) {
 740                                         err(1, "write");
 741                                 }
 742                                 tcmd_rdwr_done(atio, ctio, AIO_DONE);
 743                         } else {
 744                                 if (debug)
 745                                         warnx("write async %lu @ block "
 746                                             OFF_FMT, (unsigned long)
 747                                             (ctio->dxfer_len / sector_size),
 748                                             c_descr->offset / sector_size);
 749                                 if (aio_write(&c_descr->aiocb) < 0) {
 750                                         err(1, "aio_write"); /* XXX */
 751                                 }
 752                         }
 753                 } else {
 754                         if (debug)
 755                                 warnx("CTIO done freeing CTIO");
 756                         free_ccb((union ccb *)ctio);
 757                 }
 758                 break;
 759         default:
 760                 warnx("Unknown completion code %d", event);
 761                 abort();
 762                 /* NOTREACHED */
 763         }
 764 }
 765
 766 /* Simple ok message used by TUR, SYNC_CACHE, etc. */
 767 static int
 768 tcmd_null_ok(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 769 {
 770         if (debug) {
 771                 struct atio_descr *a_descr;
 772
 773                 a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 774                 cdb_debug(a_descr->cdb, "Sending null ok to %u : ", atio->init_id);
 775         }
 776
 777         ctio->dxfer_len = 0;
 778         ctio->ccb_h.flags &= ~CAM_DIR_MASK;
 779         ctio->ccb_h.flags |= CAM_DIR_NONE | CAM_SEND_STATUS;
 780         ctio->scsi_status = SCSI_STATUS_OK;
 781         return (0);
 782 }
 783
 784 /* Simple illegal request message used by MODE SENSE, etc. */
 785 static int
 786 tcmd_illegal_req(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
 787 {
 788         if (debug) {
 789                 struct atio_descr *a_descr;
 790
 791                 a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
 792                 cdb_debug(a_descr->cdb, "Sending ill req to %u: ", atio->init_id);
 793         }
 794
 795         tcmd_sense(atio->init_id, ctio, SSD_KEY_ILLEGAL_REQUEST,
 796                    /*asc*/0x24, /*ascq*/0);
 797         return (0);
 798 }
 799
 800 static void
 801 cdb_debug(u_int8_t *cdb, const char *msg, ...)
 802 {
 803         char msg_buf[512];
 804         int len;
 805         va_list ap;
 806
 807         va_start(ap, msg);
 808         vsnprintf(msg_buf, sizeof(msg_buf), msg, ap);
 809         va_end(ap);
 810         len = strlen(msg_buf);
 811         scsi_cdb_string(cdb, msg_buf + len, sizeof(msg_buf) - len);
 812         warnx("%s", msg_buf);
 813 }