Another update. Clarify that a shared spinlock can be acquired while holding
[dragonfly.git] / share / examples / scsi_target / scsi_target.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_target.c,v 1.5.2.5 2003/02/18 22:07:10 njl Exp $
29  * $DragonFly: src/share/examples/scsi_target/scsi_target.c,v 1.2 2003/06/17 04:36:57 dillon Exp $
30  */
31
32 #include <sys/types.h>
33 #include <errno.h>
34 #include <err.h>
35 #include <fcntl.h>
36 #include <signal.h>
37 #include <stddef.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <sysexits.h>
42 #include <unistd.h>
43 #include <aio.h>
44 #include <assert.h>
45 #include <sys/stat.h>
46 #include <sys/queue.h>
47 #include <sys/event.h>
48 #include <sys/param.h>
49 #include <cam/cam_queue.h>
50 #include <cam/scsi/scsi_all.h>
51 #include <cam/scsi/scsi_targetio.h>
52 #include <cam/scsi/scsi_message.h>
53 #include "scsi_target.h"
54
55 /* Maximum amount to transfer per CTIO */
56 #define MAX_XFER        MAXPHYS
57 /* Maximum number of allocated CTIOs */
58 #define MAX_CTIOS       32
59 /* Maximum sector size for emulated volume */
60 #define MAX_SECTOR      32768
61
62 /* Global variables */
63 int             debug;
64 u_int32_t       volume_size;
65 size_t          sector_size;
66 size_t          buf_size;
67
68 /* Local variables */
69 static int    targ_fd;
70 static int    kq_fd;
71 static int    file_fd;
72 static int    num_ctios;
73 static struct ccb_queue         pending_queue;
74 static struct ccb_queue         work_queue;
75 static struct ioc_enable_lun    ioc_enlun = {
76         CAM_BUS_WILDCARD,
77         CAM_TARGET_WILDCARD,
78         CAM_LUN_WILDCARD
79 };
80
81 /* Local functions */
82 static void             cleanup(void);
83 static int              init_ccbs(void);
84 static void             request_loop(void);
85 static void             handle_read(void);
86 /* static int           work_atio(struct ccb_accept_tio *); */
87 static void             queue_io(struct ccb_scsiio *);
88 static void             run_queue(struct ccb_accept_tio *);
89 static int              work_inot(struct ccb_immed_notify *);
90 static struct ccb_scsiio *
91                         get_ctio(void);
92 /* static void          free_ccb(union ccb *); */
93 static cam_status       get_sim_flags(u_int16_t *);
94 static void             rel_simq(void);
95 static void             abort_all_pending(void);
96 static void             usage(void);
97
98 int
99 main(int argc, char *argv[])
100 {
101         int ch, unit;
102         char *file_name, targname[16];
103         u_int16_t req_flags, sim_flags;
104         off_t user_size;
105
106         /* Initialize */
107         debug = 0;
108         req_flags = sim_flags = 0;
109         user_size = 0;
110         targ_fd = file_fd = kq_fd = -1;
111         num_ctios = 0;
112         sector_size = SECTOR_SIZE;
113         buf_size = DFLTPHYS;
114
115         /* Prepare resource pools */
116         TAILQ_INIT(&pending_queue);
117         TAILQ_INIT(&work_queue);
118
119         while ((ch = getopt(argc, argv, "AdSTb:c:s:W:")) != -1) {
120                 switch(ch) {
121                 case 'A':
122                         req_flags |= SID_Addr16;
123                         break;
124                 case 'd':
125                         debug = 1;
126                         break;
127                 case 'S':
128                         req_flags |= SID_Sync;
129                         break;
130                 case 'T':
131                         req_flags |= SID_CmdQue;
132                         break;
133                 case 'b':
134                         buf_size = atoi(optarg);
135                         if (buf_size < 256 || buf_size > MAX_XFER)
136                                 errx(1, "Unreasonable buf size: %s", optarg);
137                         break;
138                 case 'c':
139                         sector_size = atoi(optarg);
140                         if (sector_size < 512 || sector_size > MAX_SECTOR)
141                                 errx(1, "Unreasonable sector size: %s", optarg);
142                         break;
143                 case 's':
144                         user_size = strtoll(optarg, (char **)NULL, /*base*/10);
145                         if (user_size < 0)
146                                 errx(1, "Unreasonable volume size: %s", optarg);
147                         break;
148                 case 'W':
149                         req_flags &= ~(SID_WBus16 | SID_WBus32);
150                         switch (atoi(optarg)) {
151                         case 8:
152                                 /* Leave req_flags zeroed */
153                                 break;
154                         case 16:
155                                 req_flags |= SID_WBus16;
156                                 break;
157                         case 32:
158                                 req_flags |= SID_WBus32;
159                                 break;
160                         default:
161                                 warnx("Width %s not supported", optarg);
162                                 usage();
163                                 /* NOTREACHED */
164                         }
165                         break;
166                 default:
167                         usage();
168                         /* NOTREACHED */
169                 }
170         }
171         argc -= optind;
172         argv += optind;
173         
174         if (argc != 2)
175                 usage();
176
177         sscanf(argv[0], "%u:%u:%u", &ioc_enlun.path_id, &ioc_enlun.target_id,
178                &ioc_enlun.lun_id);
179         file_name = argv[1];
180
181         if (ioc_enlun.path_id == CAM_BUS_WILDCARD ||
182             ioc_enlun.target_id == CAM_TARGET_WILDCARD ||
183             ioc_enlun.lun_id == CAM_LUN_WILDCARD) {
184                 warnx("Incomplete target path specified");
185                 usage();
186                 /* NOTREACHED */
187         }
188         /* We don't support any vendor-specific commands */
189         ioc_enlun.grp6_len = 0;
190         ioc_enlun.grp7_len = 0;
191
192         /* Open backing store for IO */
193         file_fd = open(file_name, O_RDWR);
194         if (file_fd < 0)
195                 err(1, "open backing store file");
196
197         /* Check backing store size or use the size user gave us */
198         if (user_size == 0) {
199                 struct stat st;
200
201                 if (fstat(file_fd, &st) < 0)
202                         err(1, "fstat file");
203                 volume_size = st.st_size / sector_size;
204         } else {
205                 volume_size = user_size / sector_size;
206         }
207         if (volume_size <= 0)
208                 errx(1, "volume must be larger than %d", sector_size);
209
210         {
211                 struct aiocb aio, *aiop;
212                 
213                 /* Make sure we have working AIO support */
214                 memset(&aio, 0, sizeof(aio));
215                 aio.aio_buf = malloc(sector_size);
216                 if (aio.aio_buf == NULL)
217                         err(1, "malloc");
218                 aio.aio_fildes = file_fd;
219                 aio.aio_offset = 0;
220                 aio.aio_nbytes = sector_size;
221                 signal(SIGSYS, SIG_IGN);
222                 if (aio_read(&aio) != 0) {
223                         printf("You must enable VFS_AIO in your kernel "
224                                "or load the aio(4) module.\n");
225                         err(1, "aio_read");
226                 }
227                 if (aio_waitcomplete(&aiop, NULL) != sector_size)
228                         err(1, "aio_waitcomplete");
229                 assert(aiop == &aio);
230                 signal(SIGSYS, SIG_DFL);
231                 free((void *)aio.aio_buf);
232                 if (debug)
233                         warnx("aio support tested ok");
234         }
235
236         /* Go through all the control devices and find one that isn't busy. */
237         unit = 0;
238         do {
239                 snprintf(targname, sizeof(targname), "/dev/targ%d", unit++);
240                 targ_fd = open(targname, O_RDWR);
241         } while (targ_fd < 0 && errno == EBUSY);
242
243         if (targ_fd < 0)
244             err(1, "Tried to open %d devices, none available", unit);
245
246         /* The first three are handled by kevent() later */
247         signal(SIGHUP, SIG_IGN);
248         signal(SIGINT, SIG_IGN);
249         signal(SIGTERM, SIG_IGN);
250         signal(SIGPROF, SIG_IGN);
251         signal(SIGALRM, SIG_IGN);
252         signal(SIGSTOP, SIG_IGN);
253         signal(SIGTSTP, SIG_IGN);
254
255         /* Register a cleanup handler to run when exiting */
256         atexit(cleanup);
257
258         /* Enable listening on the specified LUN */
259         if (ioctl(targ_fd, TARGIOCENABLE, &ioc_enlun) != 0)
260                 err(1, "TARGIOCENABLE");
261
262         /* Enable debugging if requested */
263         if (debug) {
264                 if (ioctl(targ_fd, TARGIOCDEBUG, &debug) != 0)
265                         err(1, "TARGIOCDEBUG");
266         }
267
268         /* Set up inquiry data according to what SIM supports */
269         if (get_sim_flags(&sim_flags) != CAM_REQ_CMP)
270                 errx(1, "get_sim_flags");
271         if (tcmd_init(req_flags, sim_flags) != 0)
272                 errx(1, "Initializing tcmd subsystem failed");
273
274         /* Queue ATIOs and INOTs on descriptor */
275         if (init_ccbs() != 0)
276                 errx(1, "init_ccbs failed");
277
278         if (debug)
279                 warnx("main loop beginning");
280         request_loop();
281
282         exit(0);
283 }
284
285 static void
286 cleanup()
287 {
288         struct ccb_hdr *ccb_h;
289
290         if (debug) {
291                 warnx("cleanup called");
292                 debug = 0;
293                 ioctl(targ_fd, TARGIOCDEBUG, &debug);
294         }
295         ioctl(targ_fd, TARGIOCDISABLE, NULL);
296         close(targ_fd);
297
298         while ((ccb_h = TAILQ_FIRST(&pending_queue)) != NULL) {
299                 TAILQ_REMOVE(&pending_queue, ccb_h, periph_links.tqe);
300                 free_ccb((union ccb *)ccb_h);
301         }
302         while ((ccb_h = TAILQ_FIRST(&work_queue)) != NULL) {
303                 TAILQ_REMOVE(&work_queue, ccb_h, periph_links.tqe);
304                 free_ccb((union ccb *)ccb_h);
305         }
306
307         if (kq_fd != -1)
308                 close(kq_fd);
309 }
310
311 /* Allocate ATIOs/INOTs and queue on HBA */
312 static int
313 init_ccbs()
314 {
315         int i;
316
317         for (i = 0; i < MAX_INITIATORS; i++) {
318                 struct ccb_accept_tio *atio;
319                 struct atio_descr *a_descr;
320                 struct ccb_immed_notify *inot;
321
322                 atio = (struct ccb_accept_tio *)malloc(sizeof(*atio));
323                 if (atio == NULL) {
324                         warn("malloc ATIO");
325                         return (-1);
326                 }
327                 a_descr = (struct atio_descr *)malloc(sizeof(*a_descr));
328                 if (a_descr == NULL) {
329                         free(atio);
330                         warn("malloc atio_descr");
331                         return (-1);
332                 }
333                 atio->ccb_h.func_code = XPT_ACCEPT_TARGET_IO;
334                 atio->ccb_h.targ_descr = a_descr;
335                 send_ccb((union ccb *)atio, /*priority*/1);
336
337                 inot = (struct ccb_immed_notify *)malloc(sizeof(*inot));
338                 if (inot == NULL) {
339                         warn("malloc INOT");
340                         return (-1);
341                 }
342                 inot->ccb_h.func_code = XPT_IMMED_NOTIFY;
343                 send_ccb((union ccb *)inot, /*priority*/1);
344         }
345
346         return (0);
347 }
348
349 static void
350 request_loop()
351 {
352         struct kevent events[MAX_EVENTS];
353         struct timespec ts, *tptr;
354         int quit;
355
356         /* Register kqueue for event notification */
357         if ((kq_fd = kqueue()) < 0)
358                 err(1, "init kqueue");
359
360         /* Set up some default events */
361         EV_SET(&events[0], SIGHUP, EVFILT_SIGNAL, EV_ADD|EV_ENABLE, 0, 0, 0);
362         EV_SET(&events[1], SIGINT, EVFILT_SIGNAL, EV_ADD|EV_ENABLE, 0, 0, 0);
363         EV_SET(&events[2], SIGTERM, EVFILT_SIGNAL, EV_ADD|EV_ENABLE, 0, 0, 0);
364         EV_SET(&events[3], targ_fd, EVFILT_READ, EV_ADD|EV_ENABLE, 0, 0, 0);
365         if (kevent(kq_fd, events, 4, NULL, 0, NULL) < 0)
366                 err(1, "kevent signal registration");
367
368         ts.tv_sec = 0;
369         ts.tv_nsec = 0;
370         tptr = NULL;
371         quit = 0;
372
373         /* Loop until user signal */
374         while (quit == 0) {
375                 int retval, i;
376                 struct ccb_hdr *ccb_h;
377
378                 /* Check for the next signal, read ready, or AIO completion */
379                 retval = kevent(kq_fd, NULL, 0, events, MAX_EVENTS, tptr);
380                 if (retval < 0) {
381                         if (errno == EINTR) {
382                                 if (debug)
383                                         warnx("EINTR, looping");
384                                 continue;
385                         }
386                         else {
387                                 err(1, "kevent failed");
388                         }
389                 } else if (retval > MAX_EVENTS) {
390                         errx(1, "kevent returned more events than allocated?");
391                 }
392
393                 /* Process all received events. */
394                 for (i = 0; i < retval; i++) {
395                         if ((events[i].flags & EV_ERROR) != 0)
396                                 errx(1, "kevent registration failed");
397
398                         switch (events[i].filter) {
399                         case EVFILT_READ:
400                                 if (debug)
401                                         warnx("read ready");
402                                 handle_read();
403                                 break;
404                         case EVFILT_AIO:
405                         {
406                                 struct ccb_scsiio *ctio;
407                                 struct ctio_descr *c_descr;
408                                 if (debug)
409                                         warnx("aio ready");
410
411                                 ctio = (struct ccb_scsiio *)events[i].udata;
412                                 c_descr = (struct ctio_descr *)
413                                           ctio->ccb_h.targ_descr;
414                                 c_descr->event = AIO_DONE;
415                                 /* Queue on the appropriate ATIO */
416                                 queue_io(ctio);
417                                 /* Process any queued completions. */
418                                 run_queue(c_descr->atio);
419                                 break;
420                         }
421                         case EVFILT_SIGNAL:
422                                 if (debug)
423                                         warnx("signal ready, setting quit");
424                                 quit = 1;
425                                 break;
426                         default:
427                                 warnx("unknown event %#x", events[i].filter);
428                                 break;
429                         }
430
431                         if (debug)
432                                 warnx("event done");
433                 }
434
435                 /* Grab the first CCB and perform one work unit. */
436                 if ((ccb_h = TAILQ_FIRST(&work_queue)) != NULL) {
437                         union ccb *ccb;
438
439                         ccb = (union ccb *)ccb_h;
440                         switch (ccb_h->func_code) {
441                         case XPT_ACCEPT_TARGET_IO:
442                                 /* Start one more transfer. */
443                                 retval = work_atio(&ccb->atio);
444                                 break;
445                         case XPT_IMMED_NOTIFY:
446                                 retval = work_inot(&ccb->cin);
447                                 break;
448                         default:
449                                 warnx("Unhandled ccb type %#x on workq",
450                                       ccb_h->func_code);
451                                 abort();
452                                 /* NOTREACHED */
453                         }
454
455                         /* Assume work function handled the exception */
456                         if ((ccb_h->status & CAM_DEV_QFRZN) != 0) {
457                                 if (debug) {
458                                         warnx("Queue frozen receiving CCB, "
459                                               "releasing");
460                                 }
461                                 rel_simq();
462                         }
463
464                         /* No more work needed for this command. */
465                         if (retval == 0) {
466                                 TAILQ_REMOVE(&work_queue, ccb_h,
467                                              periph_links.tqe);
468                         }
469                 }
470
471                 /*
472                  * Poll for new events (i.e. completions) while we
473                  * are processing CCBs on the work_queue. Once it's
474                  * empty, use an infinite wait.
475                  */
476                 if (!TAILQ_EMPTY(&work_queue))
477                         tptr = &ts;
478                 else
479                         tptr = NULL;
480         }
481 }
482
483 /* CCBs are ready from the kernel */
484 static void
485 handle_read()
486 {
487         union ccb *ccb_array[MAX_INITIATORS], *ccb;
488         int ccb_count, i;
489
490         ccb_count = read(targ_fd, ccb_array, sizeof(ccb_array));
491         if (ccb_count <= 0) {
492                 warn("read ccb ptrs");
493                 return;
494         }
495         ccb_count /= sizeof(union ccb *);
496         if (ccb_count < 1) {
497                 warnx("truncated read ccb ptr?");
498                 return;
499         }
500
501         for (i = 0; i < ccb_count; i++) {
502                 ccb = ccb_array[i];
503                 TAILQ_REMOVE(&pending_queue, &ccb->ccb_h, periph_links.tqe);
504
505                 switch (ccb->ccb_h.func_code) {
506                 case XPT_ACCEPT_TARGET_IO:
507                 {
508                         struct ccb_accept_tio *atio;
509                         struct atio_descr *a_descr;
510
511                         /* Initialize ATIO descr for this transaction */
512                         atio = &ccb->atio;
513                         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
514                         bzero(a_descr, sizeof(*a_descr));
515                         TAILQ_INIT(&a_descr->cmplt_io);
516                         a_descr->flags = atio->ccb_h.flags &
517                                 (CAM_DIS_DISCONNECT | CAM_TAG_ACTION_VALID);
518                         /* XXX add a_descr->priority */
519                         if ((atio->ccb_h.flags & CAM_CDB_POINTER) == 0)
520                                 a_descr->cdb = atio->cdb_io.cdb_bytes;
521                         else
522                                 a_descr->cdb = atio->cdb_io.cdb_ptr;
523
524                         /* ATIOs are processed in FIFO order */
525                         TAILQ_INSERT_TAIL(&work_queue, &ccb->ccb_h,
526                                           periph_links.tqe);
527                         break;
528                 }
529                 case XPT_CONT_TARGET_IO:
530                 {
531                         struct ccb_scsiio *ctio;
532                         struct ctio_descr *c_descr;
533
534                         ctio = &ccb->ctio;
535                         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
536                         c_descr->event = CTIO_DONE;
537                         /* Queue on the appropriate ATIO */
538                         queue_io(ctio);
539                         /* Process any queued completions. */
540                         run_queue(c_descr->atio);
541                         break;
542                 }
543                 case XPT_IMMED_NOTIFY:
544                         /* INOTs are handled with priority */
545                         TAILQ_INSERT_HEAD(&work_queue, &ccb->ccb_h,
546                                           periph_links.tqe);
547                         break;
548                 default:
549                         warnx("Unhandled ccb type %#x in handle_read",
550                               ccb->ccb_h.func_code);
551                         break;
552                 }
553         }
554 }
555
556 /* Process an ATIO CCB from the kernel */
557 int
558 work_atio(struct ccb_accept_tio *atio)
559 {
560         struct ccb_scsiio *ctio;
561         struct atio_descr *a_descr;
562         struct ctio_descr *c_descr;
563         cam_status status;
564         int ret;
565
566         if (debug)
567                 warnx("Working on ATIO %p", atio);
568
569         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
570
571         /* Get a CTIO and initialize it according to our known parameters */
572         ctio = get_ctio();
573         if (ctio == NULL)
574                 return (1);
575         ret = 0;
576         ctio->ccb_h.flags = a_descr->flags;
577         ctio->tag_id = atio->tag_id;
578         ctio->init_id = atio->init_id;
579         /* XXX priority needs to be added to a_descr */
580         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
581         c_descr->atio = atio;
582         if ((a_descr->flags & CAM_DIR_IN) != 0)
583                 c_descr->offset = a_descr->base_off + a_descr->targ_req;
584         else if ((a_descr->flags & CAM_DIR_MASK) == CAM_DIR_OUT)
585                 c_descr->offset = a_descr->base_off + a_descr->init_req;
586
587         /* 
588          * Return a check condition if there was an error while
589          * receiving this ATIO.
590          */
591         if (atio->sense_len != 0) {
592                 struct scsi_sense_data *sense;
593
594                 if (debug) {
595                         warnx("ATIO with %u bytes sense received",
596                               atio->sense_len);
597                 }
598                 sense = &atio->sense_data;
599                 tcmd_sense(ctio->init_id, ctio, sense->flags,
600                            sense->add_sense_code, sense->add_sense_code_qual);
601                 send_ccb((union ccb *)ctio, /*priority*/1);
602                 return (0);
603         }
604
605         status = atio->ccb_h.status & CAM_STATUS_MASK;
606         switch (status) {
607         case CAM_CDB_RECVD:
608                 ret = tcmd_handle(atio, ctio, ATIO_WORK);
609                 break;
610         case CAM_REQ_ABORTED:
611                 /* Requeue on HBA */
612                 TAILQ_REMOVE(&work_queue, &atio->ccb_h, periph_links.tqe);
613                 send_ccb((union ccb *)atio, /*priority*/1);
614                 ret = 1;
615                 break;
616         default:
617                 warnx("ATIO completed with unhandled status %#x", status);
618                 abort();
619                 /* NOTREACHED */
620                 break;
621         }
622
623         return (ret);
624 }
625
626 static void
627 queue_io(struct ccb_scsiio *ctio)
628 {
629         struct ccb_hdr *ccb_h;
630         struct io_queue *ioq;
631         struct ctio_descr *c_descr, *curr_descr;
632         
633         c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
634         /* If the completion is for a specific ATIO, queue in order */
635         if (c_descr->atio != NULL) {
636                 struct atio_descr *a_descr;
637
638                 a_descr = (struct atio_descr *)c_descr->atio->ccb_h.targ_descr;
639                 ioq = &a_descr->cmplt_io;
640         } else {
641                 errx(1, "CTIO %p has NULL ATIO", ctio);
642         }
643
644         /* Insert in order, sorted by offset */
645         if (!TAILQ_EMPTY(ioq)) {
646                 TAILQ_FOREACH_REVERSE(ccb_h, ioq, io_queue, periph_links.tqe) {
647                         curr_descr = (struct ctio_descr *)ccb_h->targ_descr;
648                         if (curr_descr->offset <= c_descr->offset) {
649                                 TAILQ_INSERT_AFTER(ioq, ccb_h, &ctio->ccb_h,
650                                                    periph_links.tqe);
651                                 break;
652                         }
653                         if (TAILQ_PREV(ccb_h, io_queue, periph_links.tqe)
654                             == NULL) {
655                                 TAILQ_INSERT_BEFORE(ccb_h, &ctio->ccb_h, 
656                                                     periph_links.tqe);
657                                 break;
658                         }
659                 }
660         } else {
661                 TAILQ_INSERT_HEAD(ioq, &ctio->ccb_h, periph_links.tqe);
662         }
663 }
664
665 /*
666  * Go through all completed AIO/CTIOs for a given ATIO and advance data
667  * counts, start continuation IO, etc.
668  */
669 static void
670 run_queue(struct ccb_accept_tio *atio)
671 {
672         struct atio_descr *a_descr;
673         struct ccb_hdr *ccb_h;
674         int sent_status, event;
675
676         if (atio == NULL)
677                 return;
678
679         a_descr = (struct atio_descr *)atio->ccb_h.targ_descr;
680
681         while ((ccb_h = TAILQ_FIRST(&a_descr->cmplt_io)) != NULL) {
682                 struct ccb_scsiio *ctio;
683                 struct ctio_descr *c_descr;
684
685                 ctio = (struct ccb_scsiio *)ccb_h;
686                 c_descr = (struct ctio_descr *)ctio->ccb_h.targ_descr;
687
688                 /* If completed item is in range, call handler */
689                 if ((c_descr->event == AIO_DONE &&
690                     c_descr->offset == a_descr->base_off + a_descr->targ_ack)
691                  || (c_descr->event == CTIO_DONE &&
692                     c_descr->offset == a_descr->base_off + a_descr->init_ack)) {
693                         sent_status = (ccb_h->flags & CAM_SEND_STATUS) != 0;
694                         event = c_descr->event;
695
696                         TAILQ_REMOVE(&a_descr->cmplt_io, ccb_h,
697                                      periph_links.tqe);
698                         tcmd_handle(atio, ctio, c_descr->event);
699
700                         /* If entire transfer complete, send back ATIO */
701                         if (sent_status != 0 && event == CTIO_DONE)
702                                 send_ccb((union ccb *)atio, /*priority*/1);
703                 } else {
704                         /* Gap in offsets so wait until later callback */
705                         if (debug)
706                                 warnx("IO %p out of order", ccb_h);
707                         break;
708                 }
709         }
710 }
711
712 static int
713 work_inot(struct ccb_immed_notify *inot)
714 {
715         cam_status status;
716         int sense;
717
718         if (debug)
719                 warnx("Working on INOT %p", inot);
720
721         status = inot->ccb_h.status;
722         sense = (status & CAM_AUTOSNS_VALID) != 0;
723         status &= CAM_STATUS_MASK;
724
725         switch (status) {
726         case CAM_SCSI_BUS_RESET:
727                 tcmd_ua(CAM_TARGET_WILDCARD, UA_BUS_RESET);
728                 abort_all_pending();
729                 break;
730         case CAM_BDR_SENT:
731                 tcmd_ua(CAM_TARGET_WILDCARD, UA_BDR);
732                 abort_all_pending();
733                 break;
734         case CAM_MESSAGE_RECV:
735                 switch (inot->message_args[0]) {
736                 case MSG_TASK_COMPLETE:
737                 case MSG_INITIATOR_DET_ERR:
738                 case MSG_ABORT_TASK_SET:
739                 case MSG_MESSAGE_REJECT:
740                 case MSG_NOOP:
741                 case MSG_PARITY_ERROR:
742                 case MSG_TARGET_RESET:
743                 case MSG_ABORT_TASK:
744                 case MSG_CLEAR_TASK_SET:
745                 default:
746                         warnx("INOT message %#x", inot->message_args[0]);
747                         break;
748                 }
749                 break;
750         case CAM_REQ_ABORTED:
751                 warnx("INOT %p aborted", inot);
752                 break;
753         default:
754                 warnx("Unhandled INOT status %#x", status);
755                 break;
756         }
757
758         /* If there is sense data, use it */
759         if (sense != 0) {
760                 struct scsi_sense_data *sense;
761
762                 sense = &inot->sense_data;
763                 tcmd_sense(inot->initiator_id, NULL, sense->flags,
764                            sense->add_sense_code, sense->add_sense_code_qual);
765                 if (debug)
766                         warnx("INOT has sense: %#x", sense->flags);
767         }
768
769         /* Requeue on SIM */
770         TAILQ_REMOVE(&work_queue, &inot->ccb_h, periph_links.tqe);
771         send_ccb((union ccb *)inot, /*priority*/1);
772
773         return (1);
774 }
775
776 void
777 send_ccb(union ccb *ccb, int priority)
778 {
779         if (debug)
780                 warnx("sending ccb (%#x)", ccb->ccb_h.func_code);
781         ccb->ccb_h.pinfo.priority = priority;
782         if (XPT_FC_IS_QUEUED(ccb)) {
783                 TAILQ_INSERT_TAIL(&pending_queue, &ccb->ccb_h,
784                                   periph_links.tqe);
785         }
786         if (write(targ_fd, &ccb, sizeof(ccb)) != sizeof(ccb)) {
787                 warn("write ccb");
788                 ccb->ccb_h.status = CAM_PROVIDE_FAIL;
789         }
790 }
791
792 /* Return a CTIO/descr/buf combo from the freelist or malloc one */
793 static struct ccb_scsiio *
794 get_ctio()
795 {
796         struct ccb_scsiio *ctio;
797         struct ctio_descr *c_descr;
798         struct sigevent *se;
799
800         if (num_ctios == MAX_CTIOS)
801                 return (NULL);
802
803         ctio = (struct ccb_scsiio *)malloc(sizeof(*ctio));
804         if (ctio == NULL) {
805                 warn("malloc CTIO");
806                 return (NULL);
807         }
808         c_descr = (struct ctio_descr *)malloc(sizeof(*c_descr));
809         if (c_descr == NULL) {
810                 free(ctio);
811                 warn("malloc ctio_descr");
812                 return (NULL);
813         }
814         c_descr->buf = malloc(buf_size);
815         if (c_descr->buf == NULL) {
816                 free(c_descr);
817                 free(ctio);
818                 warn("malloc backing store");
819                 return (NULL);
820         }
821         num_ctios++;
822
823         /* Initialize CTIO, CTIO descr, and AIO */
824         ctio->ccb_h.func_code = XPT_CONT_TARGET_IO;
825         ctio->ccb_h.retry_count = 2;
826         ctio->ccb_h.timeout = CAM_TIME_INFINITY;
827         ctio->data_ptr = c_descr->buf;
828         ctio->ccb_h.targ_descr = c_descr;
829         c_descr->aiocb.aio_buf = c_descr->buf;
830         c_descr->aiocb.aio_fildes = file_fd;
831         se = &c_descr->aiocb.aio_sigevent;
832         se->sigev_notify = SIGEV_KEVENT;
833         se->sigev_notify_kqueue = kq_fd;
834         se->sigev_value.sigval_ptr = ctio;
835
836         return (ctio);
837 }
838
839 void
840 free_ccb(union ccb *ccb)
841 {
842         switch (ccb->ccb_h.func_code) {
843         case XPT_CONT_TARGET_IO:
844         {
845                 struct ctio_descr *c_descr;
846
847                 c_descr = (struct ctio_descr *)ccb->ccb_h.targ_descr;
848                 free(c_descr->buf);
849                 num_ctios--;
850                 /* FALLTHROUGH */
851         }
852         case XPT_ACCEPT_TARGET_IO:
853                 free(ccb->ccb_h.targ_descr);
854                 /* FALLTHROUGH */
855         case XPT_IMMED_NOTIFY:
856         default:
857                 free(ccb);
858                 break;
859         }
860 }
861
862 static cam_status
863 get_sim_flags(u_int16_t *flags)
864 {
865         struct ccb_pathinq cpi;
866         cam_status status;
867
868         /* Find SIM capabilities */
869         bzero(&cpi, sizeof(cpi));
870         cpi.ccb_h.func_code = XPT_PATH_INQ;
871         send_ccb((union ccb *)&cpi, /*priority*/1);
872         status = cpi.ccb_h.status & CAM_STATUS_MASK;
873         if (status != CAM_REQ_CMP) {
874                 fprintf(stderr, "CPI failed, status %#x\n", status);
875                 return (status);
876         }
877
878         /* Can only enable on controllers that support target mode */
879         if ((cpi.target_sprt & PIT_PROCESSOR) == 0) {
880                 fprintf(stderr, "HBA does not support target mode\n");
881                 status = CAM_PATH_INVALID;
882                 return (status);
883         }
884
885         *flags = cpi.hba_inquiry;
886         return (status);
887 }
888
889 static void
890 rel_simq()
891 {
892         struct ccb_relsim crs;
893
894         bzero(&crs, sizeof(crs));
895         crs.ccb_h.func_code = XPT_REL_SIMQ;
896         crs.release_flags = RELSIM_RELEASE_AFTER_QEMPTY;
897         crs.openings = 0;
898         crs.release_timeout = 0;
899         crs.qfrozen_cnt = 0;
900         send_ccb((union ccb *)&crs, /*priority*/0);
901 }
902
903 /* Cancel all pending CCBs. */
904 static void
905 abort_all_pending()
906 {
907         struct ccb_abort         cab;
908         struct ccb_hdr          *ccb_h;
909
910         if (debug)
911                   warnx("abort_all_pending");
912
913         bzero(&cab, sizeof(cab));
914         cab.ccb_h.func_code = XPT_ABORT;
915         TAILQ_FOREACH(ccb_h, &pending_queue, periph_links.tqe) {
916                 if (debug)
917                           warnx("Aborting pending CCB %p\n", ccb_h);
918                 cab.abort_ccb = (union ccb *)ccb_h;
919                 send_ccb((union ccb *)&cab, /*priority*/1);
920                 if (cab.ccb_h.status != CAM_REQ_CMP) {
921                         warnx("Unable to abort CCB, status %#x\n",
922                                cab.ccb_h.status);
923                 }
924         }
925 }
926
927 static void
928 usage()
929 {
930         fprintf(stderr,
931                 "Usage: scsi_target [-AdST] [-b bufsize] [-c sectorsize]\n"
932                 "\t\t[-r numbufs] [-s volsize] [-W 8,16,32]\n"
933                 "\t\tbus:target:lun filename\n");
934         exit(1);
935 }