Another update. Clarify that a shared spinlock can be acquired while holding
[dragonfly.git] / 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: src/share/examples/scsi_target/scsi_cmds.c,v 1.2.2.1 2003/02/18 22:07:10 njl Exp $
29  * $DragonFly: src/share/examples/scsi_target/scsi_cmds.c,v 1.2 2003/06/17 04:36:57 dillon Exp $
30  */
31
32 #include <stdio.h>
33 #include <stddef.h>
34 #include <stdarg.h>
35 #include <string.h>
36 #include <err.h>
37 #include <aio.h>
38 #include <assert.h>
39 #include <sys/types.h>
40
41 #include <cam/cam.h>
42 #include <cam/cam_ccb.h>
43 #include <cam/scsi/scsi_all.h>
44 #include <cam/scsi/scsi_targetio.h>
45 #include "scsi_target.h"
46
47 typedef int targ_start_func(struct ccb_accept_tio *, struct ccb_scsiio *);
48 typedef void targ_done_func(struct ccb_accept_tio *, struct ccb_scsiio *,
49                               io_ops);
50
51 struct targ_cdb_handlers {
52         u_int8_t          cmd;
53         targ_start_func  *start;
54         targ_done_func   *done;
55 #define ILLEGAL_CDB       0xFF
56 };
57
58 static targ_start_func          tcmd_inquiry;
59 static targ_start_func          tcmd_req_sense;
60 static targ_start_func          tcmd_rd_cap;
61 static targ_start_func          tcmd_rdwr;
62 static targ_start_func          tcmd_rdwr_decode;
63 static targ_done_func           tcmd_rdwr_done;
64 static targ_start_func          tcmd_null_ok;
65 static targ_start_func          tcmd_illegal_req;
66 static int                      start_io(struct ccb_accept_tio *atio,
67                                          struct ccb_scsiio *ctio, int dir);
68 static int init_inquiry(u_int16_t req_flags, u_int16_t sim_flags);
69 static struct initiator_state *
70                         tcmd_get_istate(u_int init_id);
71 static void cdb_debug(u_int8_t *cdb, const char *msg, ...);
72
73 static struct targ_cdb_handlers cdb_handlers[] = { 
74         { READ_10,              tcmd_rdwr,              tcmd_rdwr_done },
75         { WRITE_10,             tcmd_rdwr,              tcmd_rdwr_done },
76         { READ_6,               tcmd_rdwr,              tcmd_rdwr_done },
77         { WRITE_6,              tcmd_rdwr,              tcmd_rdwr_done },
78         { INQUIRY,              tcmd_inquiry,           NULL },
79         { REQUEST_SENSE,        tcmd_req_sense,         NULL },
80         { READ_CAPACITY,        tcmd_rd_cap,            NULL },
81         { TEST_UNIT_READY,      tcmd_null_ok,           NULL },
82         { START_STOP_UNIT,      tcmd_null_ok,           NULL },
83         { SYNCHRONIZE_CACHE,    tcmd_null_ok,           NULL },
84         { MODE_SENSE_6,         tcmd_illegal_req,       NULL },
85         { MODE_SELECT_6,        tcmd_illegal_req,       NULL },
86         { ILLEGAL_CDB,          NULL,                   NULL }
87 };
88
89 static struct scsi_inquiry_data inq_data;
90 static struct initiator_state istates[MAX_INITIATORS];
91 extern int              debug;
92 extern u_int32_t        volume_size;
93 extern size_t           sector_size;
94 extern size_t           buf_size;
95
96 cam_status
97 tcmd_init(u_int16_t req_inq_flags, u_int16_t sim_inq_flags)
98 {
99         struct initiator_state *istate;
100         int i, ret;
101
102         /* Initialize our inquiry data */
103         ret = init_inquiry(req_inq_flags, sim_inq_flags);
104         if (ret != 0)
105                 return (ret);
106
107         /* We start out life with a UA to indicate power-on/reset. */
108         for (i = 0; i < MAX_INITIATORS; i++) {
109                 istate = tcmd_get_istate(i);
110                 bzero(istate, sizeof(*istate));
111                 istate->pending_ua = UA_POWER_ON;
112         }
113
114         return (0);
115 }
116
117 /* Caller allocates CTIO, sets its init_id
118 return 0 if done, 1 if more processing needed 
119 on 0, caller sets SEND_STATUS */
120 int
121 tcmd_handle(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio, io_ops event)
122 {
123         static struct targ_cdb_handlers *last_cmd; 
124         struct initiator_state *istate;
125         struct atio_descr *a_descr;
126         int ret;
127
128         if (debug) {
129                 warnx("tcmd_handle atio %p ctio %p atioflags %#x", atio, ctio,
130                       atio->ccb_h.flags);
131         }
132         ret = 0;
133         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
134
135         /* Do a full lookup if one-behind cache failed */
136         if (last_cmd == NULL || last_cmd->cmd != a_descr->cdb[0]) {
137                 struct targ_cdb_handlers *h; 
138
139                 for (h = cdb_handlers; h->cmd != ILLEGAL_CDB; h++) {
140                         if (a_descr->cdb[0] == h->cmd)
141                                 break;
142                 }
143                 last_cmd = h;
144         }
145         if (last_cmd->cmd == ILLEGAL_CDB) {
146                 if (event != ATIO_WORK) {
147                         warnx("no done func for %#x???", a_descr->cdb[0]);
148                         abort();
149                 }
150                 /* Not found, return illegal request */
151                 warnx("cdb %#x not handled", a_descr->cdb[0]);
152                 tcmd_illegal_req(atio, ctio);
153                 send_ccb((union ccb *)ctio, /*priority*/1);
154                 return (0);
155         }
156
157         /* call completion and exit */
158         if (event != ATIO_WORK) {
159                 if (last_cmd->done != NULL)
160                         last_cmd->done(atio, ctio, event);
161                 else
162                         free_ccb((union ccb *)ctio);
163                 return (1);
164         }
165
166         istate = tcmd_get_istate(ctio->init_id);
167         if (istate == NULL) {
168                 tcmd_illegal_req(atio, ctio);
169                 send_ccb((union ccb *)ctio, /*priority*/1);
170                 return (0);
171         }
172
173         if (istate->pending_ca == 0 && istate->pending_ua != 0 &&
174             a_descr->cdb[0] != INQUIRY) {
175                 tcmd_sense(ctio->init_id, ctio, SSD_KEY_UNIT_ATTENTION,
176                            0x29, istate->pending_ua == UA_POWER_ON ? 1 : 2);
177                 istate->pending_ca = CA_UNIT_ATTN;
178                 if (debug) {
179                         cdb_debug(a_descr->cdb, "UA active for %u: ",
180                                   atio->init_id);
181                 }
182                 send_ccb((union ccb *)ctio, /*priority*/1);
183                 return (0);
184         } 
185
186         /* Store current CA and UA for later */
187         istate->orig_ua = istate->pending_ua;
188         istate->orig_ca = istate->pending_ca;
189
190         /*
191          * As per SAM2, any command that occurs
192          * after a CA is reported, clears the CA.  We must
193          * also clear the UA condition, if any, that caused
194          * the CA to occur assuming the UA is not for a
195          * persistent condition.
196          */
197         istate->pending_ca = CA_NONE;
198         if (istate->orig_ca == CA_UNIT_ATTN)
199                 istate->pending_ua = UA_NONE;
200
201         /* If we have a valid handler, call start or completion function */
202         if (last_cmd->cmd != ILLEGAL_CDB) {
203                 ret = last_cmd->start(atio, ctio);
204                 /* XXX hack */
205                 if (last_cmd->start != tcmd_rdwr) {
206                         a_descr->init_req += ctio->dxfer_len;
207                         send_ccb((union ccb *)ctio, /*priority*/1);
208                 }
209         }
210
211         return (ret);
212 }
213
214 static struct initiator_state *
215 tcmd_get_istate(u_int init_id)
216 {
217         if (init_id >= MAX_INITIATORS) {
218                 warnx("illegal init_id %d, max %d", init_id, MAX_INITIATORS - 1);
219                 return (NULL);
220         } else {
221                 return (&istates[init_id]);
222         }
223 }
224
225 void
226 tcmd_sense(u_int init_id, struct ccb_scsiio *ctio, u_int8_t flags,
227                u_int8_t asc, u_int8_t ascq)
228 {
229         struct initiator_state *istate;
230         struct scsi_sense_data *sense;
231
232         /* Set our initiator's istate */
233         istate = tcmd_get_istate(init_id);
234         if (istate == NULL)
235                 return;
236         istate->pending_ca |= CA_CMD_SENSE; /* XXX set instead of or? */
237         sense = &istate->sense_data;
238         bzero(sense, sizeof(*sense));
239         sense->error_code = SSD_CURRENT_ERROR;
240         sense->flags = flags;
241         sense->add_sense_code = asc;
242         sense->add_sense_code_qual = ascq;
243         sense->extra_len =
244                 offsetof(struct scsi_sense_data, sense_key_spec[2]) -
245                 offsetof(struct scsi_sense_data, extra_len);
246
247         /* Fill out the supplied CTIO */
248         if (ctio != NULL) {
249                 /* No autosense yet
250                 bcopy(sense, &ctio->sense_data, sizeof(*sense));
251                 ctio->sense_len = sizeof(*sense);  XXX
252                 */
253                 ctio->ccb_h.flags &= ~CAM_DIR_MASK;
254                 ctio->ccb_h.flags |= CAM_DIR_NONE | /* CAM_SEND_SENSE | */
255                                      CAM_SEND_STATUS;
256                 ctio->dxfer_len = 0;
257                 ctio->scsi_status = SCSI_STATUS_CHECK_COND;
258         }
259 }
260
261 void
262 tcmd_ua(u_int init_id, ua_types new_ua)
263 {
264         struct initiator_state *istate;
265         u_int start, end;
266
267         if (init_id == CAM_TARGET_WILDCARD) {
268                 start = 0;
269                 end = MAX_INITIATORS - 1;
270         } else {
271                 start = end = init_id;
272         }
273
274         for (; start <= end; start++) {
275                 istate = tcmd_get_istate(start);
276                 if (istate == NULL)
277                         break;
278                 istate->pending_ua = new_ua;
279         }
280 }
281
282 static int
283 tcmd_inquiry(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
284 {
285         struct scsi_inquiry *inq;
286         struct atio_descr *a_descr;
287         struct initiator_state *istate;
288         struct scsi_sense_data *sense;
289
290         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
291         inq = (struct scsi_inquiry *)a_descr->cdb;
292
293         if (debug)
294                 cdb_debug(a_descr->cdb, "INQUIRY from %u: ", atio->init_id);
295         /*
296          * Validate the command.  We don't support any VPD pages, so
297          * complain if EVPD or CMDDT is set.
298          */
299         istate = tcmd_get_istate(ctio->init_id);
300         sense = &istate->sense_data;
301         if ((inq->byte2 & SI_EVPD) != 0) {
302                 tcmd_illegal_req(atio, ctio);
303                 sense->sense_key_spec[0] = SSD_SCS_VALID | SSD_FIELDPTR_CMD |
304                         SSD_BITPTR_VALID | /*bit value*/1;
305                 sense->sense_key_spec[1] = 0;
306                 sense->sense_key_spec[2] =
307                         offsetof(struct scsi_inquiry, byte2);
308         } else if (inq->page_code != 0) {
309                 tcmd_illegal_req(atio, ctio);
310                 sense->sense_key_spec[0] = SSD_SCS_VALID | SSD_FIELDPTR_CMD;
311                 sense->sense_key_spec[1] = 0;
312                 sense->sense_key_spec[2] =
313                         offsetof(struct scsi_inquiry, page_code);
314         } else {
315                 bcopy(&inq_data, ctio->data_ptr, sizeof(inq_data));
316                 ctio->dxfer_len = inq_data.additional_length + 4;
317                 ctio->dxfer_len = min(ctio->dxfer_len,
318                                       SCSI_CDB6_LEN(inq->length));
319                 ctio->ccb_h.flags |= CAM_DIR_IN | CAM_SEND_STATUS;
320                 ctio->scsi_status = SCSI_STATUS_OK;
321         }
322         return (0);
323 }
324
325 /* Initialize the inquiry response structure with the requested flags */
326 static int
327 init_inquiry(u_int16_t req_flags, u_int16_t sim_flags)
328 {
329         struct scsi_inquiry_data *inq;
330
331         inq = &inq_data;
332         bzero(inq, sizeof(*inq));
333         inq->device = T_DIRECT | (SID_QUAL_LU_CONNECTED << 5);
334         inq->version = SCSI_REV_3; /* was 2 */
335
336         /*
337          * XXX cpi.hba_inquiry doesn't support Addr16 so we give the
338          * user what they want if they ask for it.
339          */
340         if ((req_flags & SID_Addr16) != 0) {
341                 sim_flags |= SID_Addr16;
342                 warnx("Not sure SIM supports Addr16 but enabling it anyway");
343         }
344
345         /* Advertise only what the SIM can actually support */
346         req_flags &= sim_flags;
347         scsi_ulto2b(req_flags, &inq->reserved[1]);
348
349         inq->response_format = 2; /* SCSI2 Inquiry Format */
350         inq->additional_length = SHORT_INQUIRY_LENGTH -
351                 offsetof(struct scsi_inquiry_data, additional_length);
352         bcopy("FreeBSD ", inq->vendor, SID_VENDOR_SIZE);
353         bcopy("Emulated Disk   ", inq->product, SID_PRODUCT_SIZE);
354         bcopy("0.1 ", inq->revision, SID_REVISION_SIZE);
355         return (0);
356 }
357
358 static int
359 tcmd_req_sense(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
360 {
361         struct scsi_request_sense *rsense;
362         struct scsi_sense_data *sense;
363         struct initiator_state *istate;
364         size_t dlen;
365         struct atio_descr *a_descr;
366
367         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
368         rsense = (struct scsi_request_sense *)a_descr->cdb;
369         
370         istate = tcmd_get_istate(ctio->init_id);
371         sense = &istate->sense_data;
372
373         if (debug) {
374                 cdb_debug(a_descr->cdb, "REQ SENSE from %u: ", atio->init_id);
375                 warnx("Sending sense: %#x %#x %#x", sense->flags,
376                       sense->add_sense_code, sense->add_sense_code_qual);
377         }
378
379         if (istate->orig_ca == 0) {
380                 tcmd_sense(ctio->init_id, NULL, SSD_KEY_NO_SENSE, 0, 0);
381                 warnx("REQUEST SENSE from %u but no pending CA!",
382                       ctio->init_id);
383         }
384
385         bcopy(sense, ctio->data_ptr, sizeof(struct scsi_sense_data));
386         dlen = offsetof(struct scsi_sense_data, extra_len) +
387                         sense->extra_len + 1;
388         ctio->dxfer_len = min(dlen, SCSI_CDB6_LEN(rsense->length));
389         ctio->ccb_h.flags |= CAM_DIR_IN | CAM_SEND_STATUS;
390         ctio->scsi_status = SCSI_STATUS_OK;
391         return (0);
392 }
393
394 static int
395 tcmd_rd_cap(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
396 {
397         struct scsi_read_capacity_data *srp;
398         struct atio_descr *a_descr;
399
400         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
401         srp = (struct scsi_read_capacity_data *)ctio->data_ptr;
402
403         if (debug) {
404                 cdb_debug(a_descr->cdb, "READ CAP from %u (%u, %u): ",
405                           atio->init_id, volume_size - 1, sector_size);
406         }
407
408         bzero(srp, sizeof(*srp));
409         scsi_ulto4b(volume_size - 1, srp->addr);
410         scsi_ulto4b(sector_size, srp->length);
411
412         ctio->dxfer_len = sizeof(*srp);
413         ctio->ccb_h.flags |= CAM_DIR_IN | CAM_SEND_STATUS;
414         ctio->scsi_status = SCSI_STATUS_OK;
415         return (0);
416 }
417
418 static int
419 tcmd_rdwr(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
420 {
421         struct atio_descr *a_descr;
422         struct ctio_descr *c_descr;
423         int ret;
424
425         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
426         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
427
428         /* Command needs to be decoded */
429         if ((a_descr->flags & CAM_DIR_MASK) == CAM_DIR_RESV) {
430                 if (debug)
431                         warnx("Calling rdwr_decode");
432                 ret = tcmd_rdwr_decode(atio, ctio);
433                 if (ret == 0) {
434                         send_ccb((union ccb *)ctio, /*priority*/1);
435                         return (0);
436                 }
437         }
438         ctio->ccb_h.flags |= a_descr->flags;
439
440         /* Call appropriate work function */
441         if ((a_descr->flags & CAM_DIR_IN) != 0) {
442                 ret = start_io(atio, ctio, CAM_DIR_IN);
443                 if (debug)
444                         warnx("Starting DIR_IN @%lld:%u", c_descr->offset,
445                               a_descr->targ_req);
446         } else {
447                 ret = start_io(atio, ctio, CAM_DIR_OUT);
448                 if (debug)
449                         warnx("Starting DIR_OUT @%lld:%u", c_descr->offset,
450                               a_descr->init_req);
451         }
452
453         return (ret);
454 }
455
456 static int
457 tcmd_rdwr_decode(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
458 {
459         u_int32_t blkno, count;
460         struct atio_descr *a_descr;
461         u_int8_t *cdb;
462
463         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
464         cdb = a_descr->cdb;
465         if (debug)
466                 cdb_debug(cdb, "R/W from %u: ", atio->init_id);
467
468         if (cdb[0] == READ_6 || cdb[0] == WRITE_6) {
469                 struct scsi_rw_6 *rw_6 = (struct scsi_rw_6 *)cdb;
470                 blkno = scsi_3btoul(rw_6->addr);
471                 count = rw_6->length;
472         } else {
473                 struct scsi_rw_10 *rw_10 = (struct scsi_rw_10 *)cdb;
474                 blkno = scsi_4btoul(rw_10->addr);
475                 count = scsi_2btoul(rw_10->length);
476         }
477         if (blkno + count > volume_size) {
478                 warnx("Attempt to access past end of volume");
479                 tcmd_sense(ctio->init_id, ctio,
480                            SSD_KEY_ILLEGAL_REQUEST, 0x21, 0);
481                 return (0);
482         }
483
484         /* Get an (overall) data length and set direction */
485         a_descr->base_off = ((off_t)blkno) * sector_size;
486         a_descr->total_len = count * sector_size;
487         if (a_descr->total_len == 0) {
488                 if (debug)
489                         warnx("r/w 0 blocks @ blkno %u", blkno);
490                 tcmd_null_ok(atio, ctio);
491                 return (0);
492         } else if (cdb[0] == WRITE_6 || cdb[0] == WRITE_10) {
493                 a_descr->flags |= CAM_DIR_OUT;
494                 if (debug)
495                         warnx("write %u blocks @ blkno %u", count, blkno);
496         } else {
497                 a_descr->flags |= CAM_DIR_IN;
498                 if (debug)
499                         warnx("read %u blocks @ blkno %u", count, blkno);
500         }
501         return (1);
502 }
503
504 static int
505 start_io(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio, int dir)
506 {
507         struct atio_descr *a_descr;
508         struct ctio_descr *c_descr;
509         int ret;
510
511         /* Set up common structures */
512         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
513         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
514
515         if (dir == CAM_DIR_IN) {
516                 c_descr->offset = a_descr->base_off + a_descr->targ_req;
517                 ctio->dxfer_len = a_descr->total_len - a_descr->targ_req;
518         } else {
519                 c_descr->offset = a_descr->base_off + a_descr->init_req;
520                 ctio->dxfer_len = a_descr->total_len - a_descr->init_req;
521         }
522         ctio->dxfer_len = min(ctio->dxfer_len, buf_size);
523         assert(ctio->dxfer_len >= 0);
524
525         c_descr->aiocb.aio_offset = c_descr->offset;
526         c_descr->aiocb.aio_nbytes = ctio->dxfer_len;
527
528         /* If DIR_IN, start read from target, otherwise begin CTIO xfer. */
529         ret = 1;
530         if (dir == CAM_DIR_IN) {
531                 if (aio_read(&c_descr->aiocb) < 0)
532                         err(1, "aio_read"); /* XXX */
533                 a_descr->targ_req += ctio->dxfer_len;
534                 if (a_descr->targ_req == a_descr->total_len) {
535                         ctio->ccb_h.flags |= CAM_SEND_STATUS;
536                         ctio->scsi_status = SCSI_STATUS_OK;
537                         ret = 0;
538                 }
539         } else {
540                 if (a_descr->targ_ack == a_descr->total_len)
541                         tcmd_null_ok(atio, ctio);
542                 a_descr->init_req += ctio->dxfer_len;
543                 if (a_descr->init_req == a_descr->total_len &&
544                     ctio->dxfer_len > 0) {
545                         /*
546                          * If data phase done, remove atio from workq.
547                          * The completion handler will call work_atio to
548                          * send the final status.
549                          */
550                         ret = 0;
551                 }
552                 send_ccb((union ccb *)ctio, /*priority*/1);
553         }
554
555         return (ret);
556 }
557
558 static void
559 tcmd_rdwr_done(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio,
560                io_ops event)
561 {
562         struct atio_descr *a_descr;
563         struct ctio_descr *c_descr;
564
565         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
566         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
567
568         switch (event) {
569         case AIO_DONE:
570                 if (aio_return(&c_descr->aiocb) < 0) {
571                         warn("aio_return error");
572                         /* XXX */
573                         tcmd_sense(ctio->init_id, ctio,
574                                    SSD_KEY_MEDIUM_ERROR, 0, 0);
575                         send_ccb((union ccb *)ctio, /*priority*/1);
576                         break;
577                 }
578                 a_descr->targ_ack += ctio->dxfer_len;
579                 if ((a_descr->flags & CAM_DIR_IN) != 0) {
580                         if (debug)
581                                 warnx("sending CTIO for AIO read");
582                         a_descr->init_req += ctio->dxfer_len;
583                         send_ccb((union ccb *)ctio, /*priority*/1);
584                 } else {
585                         /* Use work function to send final status */
586                         if (a_descr->init_req == a_descr->total_len)
587                                 work_atio(atio);
588                         if (debug)
589                                 warnx("AIO done freeing CTIO");
590                         free_ccb((union ccb *)ctio);
591                 }
592                 break;
593         case CTIO_DONE:
594                 if (ctio->ccb_h.status != CAM_REQ_CMP) {
595                         /* XXX */
596                         errx(1, "CTIO failed, status %#x", ctio->ccb_h.status);
597                 }
598                 a_descr->init_ack += ctio->dxfer_len;
599                 if ((a_descr->flags & CAM_DIR_MASK) == CAM_DIR_OUT &&
600                     ctio->dxfer_len > 0) {
601                         if (debug)
602                                 warnx("sending AIO for CTIO write");
603                         a_descr->targ_req += ctio->dxfer_len;
604                         if (aio_write(&c_descr->aiocb) < 0)
605                                 err(1, "aio_write"); /* XXX */
606                 } else {
607                         if (debug)
608                                 warnx("CTIO done freeing CTIO");
609                         free_ccb((union ccb *)ctio);
610                 }
611                 break;
612         default:
613                 warnx("Unknown completion code %d", event);
614                 abort();
615                 /* NOTREACHED */
616         }
617 }
618
619 /* Simple ok message used by TUR, SYNC_CACHE, etc. */
620 static int
621 tcmd_null_ok(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
622 {
623         if (debug) {
624                 struct atio_descr *a_descr;
625
626                 a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
627                 cdb_debug(a_descr->cdb, "Sending null ok to %u : ", atio->init_id);
628         }
629
630         ctio->dxfer_len = 0;
631         ctio->ccb_h.flags &= ~CAM_DIR_MASK;
632         ctio->ccb_h.flags |= CAM_DIR_NONE | CAM_SEND_STATUS;
633         ctio->scsi_status = SCSI_STATUS_OK;
634         return (0);
635 }
636
637 /* Simple illegal request message used by MODE SENSE, etc. */
638 static int
639 tcmd_illegal_req(struct ccb_accept_tio *atio, struct ccb_scsiio *ctio)
640 {
641         if (debug) {
642                 struct atio_descr *a_descr;
643
644                 a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
645                 cdb_debug(a_descr->cdb, "Sending ill req to %u: ", atio->init_id);
646         }
647         
648         tcmd_sense(atio->init_id, ctio, SSD_KEY_ILLEGAL_REQUEST,
649                    /*asc*/0x24, /*ascq*/0);
650         return (0);
651 }
652
653 static void
654 cdb_debug(u_int8_t *cdb, const char *msg, ...)
655 {
656         char msg_buf[512];
657         int len;
658         va_list ap;
659
660         va_start(ap, msg);
661         vsnprintf(msg_buf, sizeof(msg_buf), msg, ap);
662         va_end(ap);
663         len = strlen(msg_buf);
664         scsi_cdb_string(cdb, msg_buf + len, sizeof(msg_buf) - len);
665         warnx("%s", msg_buf);
666 }