sys/dev/virtio/scsi/virtio_scsi.c

   1 /*-
   2  * Copyright (c) 2012, Bryan Venteicher <bryanv@daemoninthecloset.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /* Driver for VirtIO SCSI devices. */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/kernel.h>
  35 #include <sys/kthread.h>
  36 #include <sys/malloc.h>
  37 #include <sys/module.h>
  38 #include <sys/sglist.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/lock.h>
  41 #include <sys/mutex.h>
  42 #include <sys/callout.h>
  43 #include <sys/taskqueue.h>
  44 #include <sys/queue.h>
  45 #include <sys/sbuf.h>
  46
  47 #include <machine/stdarg.h>
  48
  49 #include <machine/bus.h>
  50 #include <machine/resource.h>
  51 #include <sys/bus.h>
  52 #include <sys/rman.h>
  53
  54 #include <cam/cam.h>
  55 #include <cam/cam_ccb.h>
  56 #include <cam/cam_sim.h>
  57 #include <cam/cam_periph.h>
  58 #include <cam/cam_xpt_sim.h>
  59 #include <cam/cam_debug.h>
  60 #include <cam/scsi/scsi_all.h>
  61 #include <cam/scsi/scsi_message.h>
  62
  63 #include <dev/virtio/virtio.h>
  64 #include <dev/virtio/virtqueue.h>
  65 #include <dev/virtio/scsi/virtio_scsi.h>
  66 #include <dev/virtio/scsi/virtio_scsivar.h>
  67
  68 #include "virtio_if.h"
  69
  70 static int      vtscsi_modevent(module_t, int, void *);
  71
  72 static int      vtscsi_probe(device_t);
  73 static int      vtscsi_attach(device_t);
  74 static int      vtscsi_detach(device_t);
  75 static int      vtscsi_suspend(device_t);
  76 static int      vtscsi_resume(device_t);
  77
  78 static void     vtscsi_negotiate_features(struct vtscsi_softc *);
  79 static int      vtscsi_maximum_segments(struct vtscsi_softc *, int);
  80 static int      vtscsi_alloc_virtqueues(struct vtscsi_softc *);
  81 static void     vtscsi_write_device_config(struct vtscsi_softc *);
  82 static int      vtscsi_reinit(struct vtscsi_softc *);
  83
  84 static int      vtscsi_alloc_cam(struct vtscsi_softc *);
  85 static int      vtscsi_register_cam(struct vtscsi_softc *);
  86 static void     vtscsi_free_cam(struct vtscsi_softc *);
  87 static void     vtscsi_cam_async(void *, uint32_t, struct cam_path *, void *);
  88 static int      vtscsi_register_async(struct vtscsi_softc *);
  89 static void     vtscsi_deregister_async(struct vtscsi_softc *);
  90 static void     vtscsi_cam_action(struct cam_sim *, union ccb *);
  91 static void     vtscsi_cam_poll(struct cam_sim *);
  92
  93 static void     vtscsi_cam_scsi_io(struct vtscsi_softc *, struct cam_sim *,
  94                     union ccb *);
  95 static void     vtscsi_cam_get_tran_settings(struct vtscsi_softc *,
  96                     union ccb *);
  97 static void     vtscsi_cam_reset_bus(struct vtscsi_softc *, union ccb *);
  98 static void     vtscsi_cam_reset_dev(struct vtscsi_softc *, union ccb *);
  99 static void     vtscsi_cam_abort(struct vtscsi_softc *, union ccb *);
 100 static void     vtscsi_cam_path_inquiry(struct vtscsi_softc *,
 101                     struct cam_sim *, union ccb *);
 102
 103 static int      vtscsi_sg_append_scsi_buf(struct vtscsi_softc *,
 104                     struct sglist *, struct ccb_scsiio *);
 105 static int      vtscsi_fill_scsi_cmd_sglist(struct vtscsi_softc *,
 106                     struct vtscsi_request *, int *, int *);
 107 static int      vtscsi_execute_scsi_cmd(struct vtscsi_softc *,
 108                     struct vtscsi_request *);
 109 static int      vtscsi_start_scsi_cmd(struct vtscsi_softc *, union ccb *);
 110 static void     vtscsi_complete_abort_timedout_scsi_cmd(struct vtscsi_softc *,
 111                     struct vtscsi_request *);
 112 static int      vtscsi_abort_timedout_scsi_cmd(struct vtscsi_softc *,
 113                     struct vtscsi_request *);
 114 static void     vtscsi_timedout_scsi_cmd(void *);
 115 static cam_status vtscsi_scsi_cmd_cam_status(struct virtio_scsi_cmd_resp *);
 116 static cam_status vtscsi_complete_scsi_cmd_response(struct vtscsi_softc *,
 117                     struct ccb_scsiio *, struct virtio_scsi_cmd_resp *);
 118 static void     vtscsi_complete_scsi_cmd(struct vtscsi_softc *,
 119                     struct vtscsi_request *);
 120
 121 static void     vtscsi_poll_ctrl_req(struct vtscsi_softc *,
 122                     struct vtscsi_request *);
 123 static int      vtscsi_execute_ctrl_req(struct vtscsi_softc *,
 124                     struct vtscsi_request *, struct sglist *, int, int, int);
 125 static void     vtscsi_complete_abort_task_cmd(struct vtscsi_softc *c,
 126                     struct vtscsi_request *);
 127 static int      vtscsi_execute_abort_task_cmd(struct vtscsi_softc *,
 128                     struct vtscsi_request *);
 129 static int      vtscsi_execute_reset_dev_cmd(struct vtscsi_softc *,
 130                     struct vtscsi_request *);
 131
 132 static void     vtscsi_get_request_lun(uint8_t [], target_id_t *, lun_id_t *);
 133 static void     vtscsi_set_request_lun(struct ccb_hdr *, uint8_t []);
 134 static void     vtscsi_init_scsi_cmd_req(struct ccb_scsiio *,
 135                     struct virtio_scsi_cmd_req *);
 136 static void     vtscsi_init_ctrl_tmf_req(struct ccb_hdr *, uint32_t,
 137                     uintptr_t, struct virtio_scsi_ctrl_tmf_req *);
 138
 139 static void     vtscsi_freeze_simq(struct vtscsi_softc *, int);
 140 static int      vtscsi_thaw_simq(struct vtscsi_softc *, int);
 141
 142 static void     vtscsi_announce(struct vtscsi_softc *, uint32_t, target_id_t,
 143                     lun_id_t);
 144 static void     vtscsi_execute_rescan(struct vtscsi_softc *, target_id_t,
 145                     lun_id_t);
 146 static void     vtscsi_execute_rescan_bus(struct vtscsi_softc *);
 147
 148 static void     vtscsi_handle_event(struct vtscsi_softc *,
 149                     struct virtio_scsi_event *);
 150 static int      vtscsi_enqueue_event_buf(struct vtscsi_softc *,
 151                     struct virtio_scsi_event *);
 152 static int      vtscsi_init_event_vq(struct vtscsi_softc *);
 153 static void     vtscsi_reinit_event_vq(struct vtscsi_softc *);
 154 static void     vtscsi_drain_event_vq(struct vtscsi_softc *);
 155
 156 static void     vtscsi_complete_vqs_locked(struct vtscsi_softc *);
 157 static void     vtscsi_complete_vqs(struct vtscsi_softc *);
 158 static void     vtscsi_drain_vqs(struct vtscsi_softc *);
 159 static void     vtscsi_cancel_request(struct vtscsi_softc *,
 160                     struct vtscsi_request *);
 161 static void     vtscsi_drain_vq(struct vtscsi_softc *, struct virtqueue *);
 162 static void     vtscsi_stop(struct vtscsi_softc *);
 163 static int      vtscsi_reset_bus(struct vtscsi_softc *);
 164
 165 static void     vtscsi_init_request(struct vtscsi_softc *,
 166                     struct vtscsi_request *);
 167 static int      vtscsi_alloc_requests(struct vtscsi_softc *);
 168 static void     vtscsi_free_requests(struct vtscsi_softc *);
 169 static void     vtscsi_enqueue_request(struct vtscsi_softc *,
 170                     struct vtscsi_request *);
 171 static struct vtscsi_request * vtscsi_dequeue_request(struct vtscsi_softc *);
 172
 173 static void     vtscsi_complete_request(struct vtscsi_request *);
 174 static void     vtscsi_complete_vq(struct vtscsi_softc *, struct virtqueue *);
 175 static void     vtscsi_control_vq_task(void *, int);
 176 static void     vtscsi_event_vq_task(void *, int);
 177 static void     vtscsi_request_vq_task(void *, int);
 178
 179 static int      vtscsi_control_vq_intr(void *);
 180 static int      vtscsi_event_vq_intr(void *);
 181 static int      vtscsi_request_vq_intr(void *);
 182 static void     vtscsi_disable_vqs_intr(struct vtscsi_softc *);
 183 static void     vtscsi_enable_vqs_intr(struct vtscsi_softc *);
 184
 185 static void     vtscsi_get_tunables(struct vtscsi_softc *);
 186 static void     vtscsi_add_sysctl(struct vtscsi_softc *);
 187
 188 static void     vtscsi_printf_req(struct vtscsi_request *, const char *,
 189                     const char *, ...);
 190
 191 /* Global tunables. */
 192 /*
 193  * The current QEMU VirtIO SCSI implementation does not cancel in-flight
 194  * IO during virtio_stop(). So in-flight requests still complete after the
 195  * device reset. We would have to wait for all the in-flight IO to complete,
 196  * which defeats the typical purpose of a bus reset. We could simulate the
 197  * bus reset with either I_T_NEXUS_RESET of all the targets, or with
 198  * LOGICAL_UNIT_RESET of all the LUNs (assuming there is space in the
 199  * control virtqueue). But this isn't very useful if things really go off
 200  * the rails, so default to disabled for now.
 201  */
 202 static int vtscsi_bus_reset_disable = 1;
 203 TUNABLE_INT("hw.vtscsi.bus_reset_disable", &vtscsi_bus_reset_disable);
 204
 205 static struct virtio_feature_desc vtscsi_feature_desc[] = {
 206         { VIRTIO_SCSI_F_INOUT,          "InOut"         },
 207         { VIRTIO_SCSI_F_HOTPLUG,        "Hotplug"       },
 208
 209         { 0, NULL }
 210 };
 211
 212 static device_method_t vtscsi_methods[] = {
 213         /* Device methods. */
 214         DEVMETHOD(device_probe,         vtscsi_probe),
 215         DEVMETHOD(device_attach,        vtscsi_attach),
 216         DEVMETHOD(device_detach,        vtscsi_detach),
 217         DEVMETHOD(device_suspend,       vtscsi_suspend),
 218         DEVMETHOD(device_resume,        vtscsi_resume),
 219
 220         DEVMETHOD_END
 221 };
 222
 223 static driver_t vtscsi_driver = {
 224         "vtscsi",
 225         vtscsi_methods,
 226         sizeof(struct vtscsi_softc)
 227 };
 228 static devclass_t vtscsi_devclass;
 229
 230 DRIVER_MODULE(virtio_scsi, virtio_pci, vtscsi_driver, vtscsi_devclass,
 231     vtscsi_modevent, 0);
 232 MODULE_VERSION(virtio_scsi, 1);
 233 MODULE_DEPEND(virtio_scsi, virtio, 1, 1, 1);
 234 MODULE_DEPEND(virtio_scsi, cam, 1, 1, 1);
 235
 236 static int
 237 vtscsi_modevent(module_t mod, int type, void *unused)
 238 {
 239         int error;
 240
 241         switch (type) {
 242         case MOD_LOAD:
 243         case MOD_QUIESCE:
 244         case MOD_UNLOAD:
 245         case MOD_SHUTDOWN:
 246                 error = 0;
 247                 break;
 248         default:
 249                 error = EOPNOTSUPP;
 250                 break;
 251         }
 252
 253         return (error);
 254 }
 255
 256 static int
 257 vtscsi_probe(device_t dev)
 258 {
 259
 260         if (virtio_get_device_type(dev) != VIRTIO_ID_SCSI)
 261                 return (ENXIO);
 262
 263         device_set_desc(dev, "VirtIO SCSI Adapter");
 264
 265         return (BUS_PROBE_DEFAULT);
 266 }
 267
 268 static int
 269 vtscsi_attach(device_t dev)
 270 {
 271         struct vtscsi_softc *sc;
 272         struct virtio_scsi_config scsicfg;
 273         int error;
 274
 275         sc = device_get_softc(dev);
 276         sc->vtscsi_dev = dev;
 277
 278         VTSCSI_LOCK_INIT(sc, device_get_nameunit(dev));
 279         TAILQ_INIT(&sc->vtscsi_req_free);
 280
 281         vtscsi_get_tunables(sc);
 282         vtscsi_add_sysctl(sc);
 283
 284         virtio_set_feature_desc(dev, vtscsi_feature_desc);
 285         vtscsi_negotiate_features(sc);
 286
 287         if (virtio_with_feature(dev, VIRTIO_RING_F_INDIRECT_DESC))
 288                 sc->vtscsi_flags |= VTSCSI_FLAG_INDIRECT;
 289         if (virtio_with_feature(dev, VIRTIO_SCSI_F_INOUT))
 290                 sc->vtscsi_flags |= VTSCSI_FLAG_BIDIRECTIONAL;
 291         if (virtio_with_feature(dev, VIRTIO_SCSI_F_HOTPLUG))
 292                 sc->vtscsi_flags |= VTSCSI_FLAG_HOTPLUG;
 293
 294         virtio_read_device_config(dev, 0, &scsicfg,
 295             sizeof(struct virtio_scsi_config));
 296
 297         sc->vtscsi_max_channel = scsicfg.max_channel;
 298         sc->vtscsi_max_target = scsicfg.max_target;
 299         sc->vtscsi_max_lun = scsicfg.max_lun;
 300         sc->vtscsi_event_buf_size = scsicfg.event_info_size;
 301
 302         vtscsi_write_device_config(sc);
 303
 304         sc->vtscsi_max_nsegs = vtscsi_maximum_segments(sc, scsicfg.seg_max);
 305         sc->vtscsi_sglist = sglist_alloc(sc->vtscsi_max_nsegs, M_NOWAIT);
 306         if (sc->vtscsi_sglist == NULL) {
 307                 error = ENOMEM;
 308                 device_printf(dev, "cannot allocate sglist\n");
 309                 goto fail;
 310         }
 311
 312         error = vtscsi_alloc_virtqueues(sc);
 313         if (error) {
 314                 device_printf(dev, "cannot allocate virtqueues\n");
 315                 goto fail;
 316         }
 317
 318         error = vtscsi_init_event_vq(sc);
 319         if (error) {
 320                 device_printf(dev, "cannot populate the eventvq\n");
 321                 goto fail;
 322         }
 323
 324         error = vtscsi_alloc_requests(sc);
 325         if (error) {
 326                 device_printf(dev, "cannot allocate requests\n");
 327                 goto fail;
 328         }
 329
 330         error = vtscsi_alloc_cam(sc);
 331         if (error) {
 332                 device_printf(dev, "cannot allocate CAM structures\n");
 333                 goto fail;
 334         }
 335
 336         TASK_INIT(&sc->vtscsi_control_intr_task, 0,
 337             vtscsi_control_vq_task, sc);
 338         TASK_INIT(&sc->vtscsi_event_intr_task, 0,
 339             vtscsi_event_vq_task, sc);
 340         TASK_INIT(&sc->vtscsi_request_intr_task, 0,
 341             vtscsi_request_vq_task, sc);
 342
 343         sc->vtscsi_tq = taskqueue_create_fast("vtscsi_taskq", M_NOWAIT,
 344             taskqueue_thread_enqueue, &sc->vtscsi_tq);
 345         if (sc->vtscsi_tq == NULL) {
 346                 error = ENOMEM;
 347                 device_printf(dev, "cannot allocate taskqueue\n");
 348                 goto fail;
 349         }
 350
 351         error = virtio_setup_intr(dev, INTR_TYPE_CAM);
 352         if (error) {
 353                 device_printf(dev, "cannot setup virtqueue interrupts\n");
 354                 goto fail;
 355         }
 356
 357         taskqueue_start_threads(&sc->vtscsi_tq, 1, PI_DISK, "%s taskq",
 358             device_get_nameunit(dev));
 359
 360         vtscsi_enable_vqs_intr(sc);
 361
 362         /*
 363          * Register with CAM after interrupts are enabled so we will get
 364          * notified of the probe responses.
 365          */
 366         error = vtscsi_register_cam(sc);
 367         if (error) {
 368                 device_printf(dev, "cannot register with CAM\n");
 369                 goto fail;
 370         }
 371
 372 fail:
 373         if (error)
 374                 vtscsi_detach(dev);
 375
 376         return (error);
 377 }
 378
 379 static int
 380 vtscsi_detach(device_t dev)
 381 {
 382         struct vtscsi_softc *sc;
 383
 384         sc = device_get_softc(dev);
 385
 386         VTSCSI_LOCK(sc);
 387         sc->vtscsi_flags |= VTSCSI_FLAG_DETACH;
 388         if (device_is_attached(dev))
 389                 vtscsi_stop(sc);
 390         VTSCSI_UNLOCK(sc);
 391
 392         if (sc->vtscsi_tq != NULL) {
 393                 taskqueue_drain(sc->vtscsi_tq, &sc->vtscsi_control_intr_task);
 394                 taskqueue_drain(sc->vtscsi_tq, &sc->vtscsi_event_intr_task);
 395                 taskqueue_drain(sc->vtscsi_tq, &sc->vtscsi_request_intr_task);
 396                 taskqueue_free(sc->vtscsi_tq);
 397                 sc->vtscsi_tq = NULL;
 398         }
 399
 400         vtscsi_complete_vqs(sc);
 401         vtscsi_drain_vqs(sc);
 402
 403         vtscsi_free_cam(sc);
 404         vtscsi_free_requests(sc);
 405
 406         if (sc->vtscsi_sglist != NULL) {
 407                 sglist_free(sc->vtscsi_sglist);
 408                 sc->vtscsi_sglist = NULL;
 409         }
 410
 411         VTSCSI_LOCK_DESTROY(sc);
 412
 413         return (0);
 414 }
 415
 416 static int
 417 vtscsi_suspend(device_t dev)
 418 {
 419
 420         return (0);
 421 }
 422
 423 static int
 424 vtscsi_resume(device_t dev)
 425 {
 426
 427         return (0);
 428 }
 429
 430 static void
 431 vtscsi_negotiate_features(struct vtscsi_softc *sc)
 432 {
 433         device_t dev;
 434         uint64_t features;
 435
 436         dev = sc->vtscsi_dev;
 437         features = virtio_negotiate_features(dev, VTSCSI_FEATURES);
 438         sc->vtscsi_features = features;
 439 }
 440
 441 static int
 442 vtscsi_maximum_segments(struct vtscsi_softc *sc, int seg_max)
 443 {
 444         int nsegs;
 445
 446         nsegs = VTSCSI_MIN_SEGMENTS;
 447
 448         if (seg_max > 0) {
 449                 nsegs += MIN(seg_max, MAXPHYS / PAGE_SIZE + 1);
 450                 if (sc->vtscsi_flags & VTSCSI_FLAG_INDIRECT)
 451                         nsegs = MIN(nsegs, VIRTIO_MAX_INDIRECT);
 452         } else
 453                 nsegs += 1;
 454
 455         return (nsegs);
 456 }
 457
 458 static int
 459 vtscsi_alloc_virtqueues(struct vtscsi_softc *sc)
 460 {
 461         device_t dev;
 462         struct vq_alloc_info vq_info[3];
 463         int nvqs;
 464
 465         dev = sc->vtscsi_dev;
 466         nvqs = 3;
 467
 468         VQ_ALLOC_INFO_INIT(&vq_info[0], 0, vtscsi_control_vq_intr, sc,
 469             &sc->vtscsi_control_vq, "%s control", device_get_nameunit(dev));
 470
 471         VQ_ALLOC_INFO_INIT(&vq_info[1], 0, vtscsi_event_vq_intr, sc,
 472             &sc->vtscsi_event_vq, "%s event", device_get_nameunit(dev));
 473
 474         VQ_ALLOC_INFO_INIT(&vq_info[2], sc->vtscsi_max_nsegs,
 475             vtscsi_request_vq_intr, sc, &sc->vtscsi_request_vq,
 476             "%s request", device_get_nameunit(dev));
 477
 478         return (virtio_alloc_virtqueues(dev, 0, nvqs, vq_info));
 479 }
 480
 481 static void
 482 vtscsi_write_device_config(struct vtscsi_softc *sc)
 483 {
 484
 485         virtio_write_dev_config_4(sc->vtscsi_dev,
 486             offsetof(struct virtio_scsi_config, sense_size),
 487             VIRTIO_SCSI_SENSE_SIZE);
 488
 489         /*
 490          * This is the size in the virtio_scsi_cmd_req structure. Note
 491          * this value (32) is larger than the maximum CAM CDB size (16).
 492          */
 493         virtio_write_dev_config_4(sc->vtscsi_dev,
 494             offsetof(struct virtio_scsi_config, cdb_size),
 495             VIRTIO_SCSI_CDB_SIZE);
 496 }
 497
 498 static int
 499 vtscsi_reinit(struct vtscsi_softc *sc)
 500 {
 501         device_t dev;
 502         int error;
 503
 504         dev = sc->vtscsi_dev;
 505
 506         error = virtio_reinit(dev, sc->vtscsi_features);
 507         if (error == 0) {
 508                 vtscsi_write_device_config(sc);
 509                 vtscsi_reinit_event_vq(sc);
 510                 virtio_reinit_complete(dev);
 511
 512                 vtscsi_enable_vqs_intr(sc);
 513         }
 514
 515         vtscsi_dprintf(sc, VTSCSI_TRACE, "error=%d\n", error);
 516
 517         return (error);
 518 }
 519
 520 static int
 521 vtscsi_alloc_cam(struct vtscsi_softc *sc)
 522 {
 523         device_t dev;
 524         struct cam_devq *devq;
 525         int openings;
 526
 527         dev = sc->vtscsi_dev;
 528         openings = sc->vtscsi_nrequests - VTSCSI_RESERVED_REQUESTS;
 529
 530         devq = cam_simq_alloc(openings);
 531         if (devq == NULL) {
 532                 device_printf(dev, "cannot allocate SIM queue\n");
 533                 return (ENOMEM);
 534         }
 535
 536         sc->vtscsi_sim = cam_sim_alloc(vtscsi_cam_action, vtscsi_cam_poll,
 537             "vtscsi", sc, device_get_unit(dev), VTSCSI_MTX(sc), 1,
 538             openings, devq);
 539         if (sc->vtscsi_sim == NULL) {
 540                 cam_simq_free(devq);
 541                 device_printf(dev, "cannot allocate SIM\n");
 542                 return (ENOMEM);
 543         }
 544
 545         return (0);
 546 }
 547
 548 static int
 549 vtscsi_register_cam(struct vtscsi_softc *sc)
 550 {
 551         device_t dev;
 552         int registered, error;
 553
 554         dev = sc->vtscsi_dev;
 555         registered = 0;
 556
 557         VTSCSI_LOCK(sc);
 558
 559         if (xpt_bus_register(sc->vtscsi_sim, dev, 0) != CAM_SUCCESS) {
 560                 error = ENOMEM;
 561                 device_printf(dev, "cannot register XPT bus\n");
 562                 goto fail;
 563         }
 564
 565         registered = 1;
 566
 567         if (xpt_create_path(&sc->vtscsi_path, NULL,
 568             cam_sim_path(sc->vtscsi_sim), CAM_TARGET_WILDCARD,
 569             CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 570                 error = ENOMEM;
 571                 device_printf(dev, "cannot create bus path\n");
 572                 goto fail;
 573         }
 574
 575         VTSCSI_UNLOCK(sc);
 576
 577         /*
 578          * The async register apparently needs to be done without
 579          * the lock held, otherwise it can recurse on the lock.
 580          */
 581         if (vtscsi_register_async(sc) != CAM_REQ_CMP) {
 582                 error = EIO;
 583                 device_printf(dev, "cannot register async callback\n");
 584                 VTSCSI_LOCK(sc);
 585                 goto fail;
 586         }
 587
 588         return (0);
 589
 590 fail:
 591         if (sc->vtscsi_path != NULL) {
 592                 xpt_free_path(sc->vtscsi_path);
 593                 sc->vtscsi_path = NULL;
 594         }
 595
 596         if (registered != 0)
 597                 xpt_bus_deregister(cam_sim_path(sc->vtscsi_sim));
 598
 599         VTSCSI_UNLOCK(sc);
 600
 601         return (error);
 602 }
 603
 604 static void
 605 vtscsi_free_cam(struct vtscsi_softc *sc)
 606 {
 607
 608         VTSCSI_LOCK(sc);
 609
 610         if (sc->vtscsi_path != NULL) {
 611                 vtscsi_deregister_async(sc);
 612
 613                 xpt_free_path(sc->vtscsi_path);
 614                 sc->vtscsi_path = NULL;
 615
 616                 xpt_bus_deregister(cam_sim_path(sc->vtscsi_sim));
 617         }
 618
 619         if (sc->vtscsi_sim != NULL) {
 620                 cam_sim_free(sc->vtscsi_sim, 1);
 621                 sc->vtscsi_sim = NULL;
 622         }
 623
 624         VTSCSI_UNLOCK(sc);
 625 }
 626
 627 static void
 628 vtscsi_cam_async(void *cb_arg, uint32_t code, struct cam_path *path, void *arg)
 629 {
 630         struct cam_sim *sim;
 631         struct vtscsi_softc *sc;
 632
 633         sim = cb_arg;
 634         sc = cam_sim_softc(sim);
 635
 636         vtscsi_dprintf(sc, VTSCSI_TRACE, "code=%u\n", code);
 637
 638         /*
 639          * TODO Once QEMU supports event reporting, we should
 640          *      (un)subscribe to events here.
 641          */
 642         switch (code) {
 643         case AC_FOUND_DEVICE:
 644                 break;
 645         case AC_LOST_DEVICE:
 646                 break;
 647         }
 648 }
 649
 650 static int
 651 vtscsi_register_async(struct vtscsi_softc *sc)
 652 {
 653         struct ccb_setasync csa;
 654
 655         VTSCSI_LOCK_NOTOWNED(sc);
 656
 657         xpt_setup_ccb(&csa.ccb_h, sc->vtscsi_path, 5);
 658         csa.ccb_h.func_code = XPT_SASYNC_CB;
 659         csa.event_enable = AC_LOST_DEVICE | AC_FOUND_DEVICE;
 660         csa.callback = vtscsi_cam_async;
 661         csa.callback_arg = sc->vtscsi_sim;
 662
 663         xpt_action((union ccb *) &csa);
 664
 665         return (csa.ccb_h.status);
 666 }
 667
 668 static void
 669 vtscsi_deregister_async(struct vtscsi_softc *sc)
 670 {
 671         struct ccb_setasync csa;
 672
 673         xpt_setup_ccb(&csa.ccb_h, sc->vtscsi_path, 5);
 674         csa.ccb_h.func_code = XPT_SASYNC_CB;
 675         csa.event_enable = 0;
 676         csa.callback = vtscsi_cam_async;
 677         csa.callback_arg = sc->vtscsi_sim;
 678
 679         xpt_action((union ccb *) &csa);
 680 }
 681
 682 static void
 683 vtscsi_cam_action(struct cam_sim *sim, union ccb *ccb)
 684 {
 685         struct vtscsi_softc *sc;
 686         struct ccb_hdr *ccbh;
 687
 688         sc = cam_sim_softc(sim);
 689         ccbh = &ccb->ccb_h;
 690
 691         VTSCSI_LOCK_OWNED(sc);
 692
 693         if (sc->vtscsi_flags & VTSCSI_FLAG_DETACH) {
 694                 /*
 695                  * The VTSCSI_MTX is briefly dropped between setting
 696                  * VTSCSI_FLAG_DETACH and deregistering with CAM, so
 697                  * drop any CCBs that come in during that window.
 698                  */
 699                 ccbh->status = CAM_NO_HBA;
 700                 xpt_done(ccb);
 701                 return;
 702         }
 703
 704         switch (ccbh->func_code) {
 705         case XPT_SCSI_IO:
 706                 vtscsi_cam_scsi_io(sc, sim, ccb);
 707                 break;
 708
 709         case XPT_SET_TRAN_SETTINGS:
 710                 ccbh->status = CAM_FUNC_NOTAVAIL;
 711                 xpt_done(ccb);
 712                 break;
 713
 714         case XPT_GET_TRAN_SETTINGS:
 715                 vtscsi_cam_get_tran_settings(sc, ccb);
 716                 break;
 717
 718         case XPT_RESET_BUS:
 719                 vtscsi_cam_reset_bus(sc, ccb);
 720                 break;
 721
 722         case XPT_RESET_DEV:
 723                 vtscsi_cam_reset_dev(sc, ccb);
 724                 break;
 725
 726         case XPT_ABORT:
 727                 vtscsi_cam_abort(sc, ccb);
 728                 break;
 729
 730         case XPT_CALC_GEOMETRY:
 731                 cam_calc_geometry(&ccb->ccg, 1);
 732                 xpt_done(ccb);
 733                 break;
 734
 735         case XPT_PATH_INQ:
 736                 vtscsi_cam_path_inquiry(sc, sim, ccb);
 737                 break;
 738
 739         default:
 740                 vtscsi_dprintf(sc, VTSCSI_ERROR,
 741                     "invalid ccb=%p func=%#x\n", ccb, ccbh->func_code);
 742
 743                 ccbh->status = CAM_REQ_INVALID;
 744                 xpt_done(ccb);
 745                 break;
 746         }
 747 }
 748
 749 static void
 750 vtscsi_cam_poll(struct cam_sim *sim)
 751 {
 752         struct vtscsi_softc *sc;
 753
 754         sc = cam_sim_softc(sim);
 755
 756         vtscsi_complete_vqs_locked(sc);
 757 }
 758
 759 static void
 760 vtscsi_cam_scsi_io(struct vtscsi_softc *sc, struct cam_sim *sim,
 761     union ccb *ccb)
 762 {
 763         struct ccb_hdr *ccbh;
 764         struct ccb_scsiio *csio;
 765         int error;
 766
 767         ccbh = &ccb->ccb_h;
 768         csio = &ccb->csio;
 769
 770         if (csio->cdb_len > VIRTIO_SCSI_CDB_SIZE) {
 771                 error = EINVAL;
 772                 ccbh->status = CAM_REQ_INVALID;
 773                 goto done;
 774         }
 775
 776         if ((ccbh->flags & CAM_DIR_MASK) == CAM_DIR_BOTH &&
 777             (sc->vtscsi_flags & VTSCSI_FLAG_BIDIRECTIONAL) == 0) {
 778                 error = EINVAL;
 779                 ccbh->status = CAM_REQ_INVALID;
 780                 goto done;
 781         }
 782
 783         error = vtscsi_start_scsi_cmd(sc, ccb);
 784
 785 done:
 786         if (error) {
 787                 vtscsi_dprintf(sc, VTSCSI_ERROR,
 788                     "error=%d ccb=%p status=%#x\n", error, ccb, ccbh->status);
 789                 xpt_done(ccb);
 790         }
 791 }
 792
 793 static void
 794 vtscsi_cam_get_tran_settings(struct vtscsi_softc *sc, union ccb *ccb)
 795 {
 796         struct ccb_trans_settings *cts;
 797         struct ccb_trans_settings_scsi *scsi;
 798
 799         cts = &ccb->cts;
 800         scsi = &cts->proto_specific.scsi;
 801
 802         cts->protocol = PROTO_SCSI;
 803         cts->protocol_version = SCSI_REV_SPC3;
 804         cts->transport = XPORT_SAS;
 805         cts->transport_version = 0;
 806
 807         scsi->valid = CTS_SCSI_VALID_TQ;
 808         scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
 809
 810         ccb->ccb_h.status = CAM_REQ_CMP;
 811         xpt_done(ccb);
 812 }
 813
 814 static void
 815 vtscsi_cam_reset_bus(struct vtscsi_softc *sc, union ccb *ccb)
 816 {
 817         int error;
 818
 819         error = vtscsi_reset_bus(sc);
 820         if (error == 0)
 821                 ccb->ccb_h.status = CAM_REQ_CMP;
 822         else
 823                 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
 824
 825         vtscsi_dprintf(sc, VTSCSI_TRACE, "error=%d ccb=%p status=%#x\n",
 826             error, ccb, ccb->ccb_h.status);
 827
 828         xpt_done(ccb);
 829 }
 830
 831 static void
 832 vtscsi_cam_reset_dev(struct vtscsi_softc *sc, union ccb *ccb)
 833 {
 834         struct ccb_hdr *ccbh;
 835         struct vtscsi_request *req;
 836         int error;
 837
 838         ccbh = &ccb->ccb_h;
 839
 840         req = vtscsi_dequeue_request(sc);
 841         if (req == NULL) {
 842                 error = EAGAIN;
 843                 vtscsi_freeze_simq(sc, VTSCSI_REQUEST);
 844                 goto fail;
 845         }
 846
 847         req->vsr_ccb = ccb;
 848
 849         error = vtscsi_execute_reset_dev_cmd(sc, req);
 850         if (error == 0)
 851                 return;
 852
 853         vtscsi_enqueue_request(sc, req);
 854
 855 fail:
 856         vtscsi_dprintf(sc, VTSCSI_ERROR, "error=%d req=%p ccb=%p\n",
 857             error, req, ccb);
 858
 859         if (error == EAGAIN)
 860                 ccbh->status = CAM_RESRC_UNAVAIL;
 861         else
 862                 ccbh->status = CAM_REQ_CMP_ERR;
 863
 864         xpt_done(ccb);
 865 }
 866
 867 static void
 868 vtscsi_cam_abort(struct vtscsi_softc *sc, union ccb *ccb)
 869 {
 870         struct vtscsi_request *req;
 871         struct ccb_hdr *ccbh;
 872         int error;
 873
 874         ccbh = &ccb->ccb_h;
 875
 876         req = vtscsi_dequeue_request(sc);
 877         if (req == NULL) {
 878                 error = EAGAIN;
 879                 vtscsi_freeze_simq(sc, VTSCSI_REQUEST);
 880                 goto fail;
 881         }
 882
 883         req->vsr_ccb = ccb;
 884
 885         error = vtscsi_execute_abort_task_cmd(sc, req);
 886         if (error == 0)
 887                 return;
 888
 889         vtscsi_enqueue_request(sc, req);
 890
 891 fail:
 892         vtscsi_dprintf(sc, VTSCSI_ERROR, "error=%d req=%p ccb=%p\n",
 893             error, req, ccb);
 894
 895         if (error == EAGAIN)
 896                 ccbh->status = CAM_RESRC_UNAVAIL;
 897         else
 898                 ccbh->status = CAM_REQ_CMP_ERR;
 899
 900         xpt_done(ccb);
 901 }
 902
 903 static void
 904 vtscsi_cam_path_inquiry(struct vtscsi_softc *sc, struct cam_sim *sim,
 905     union ccb *ccb)
 906 {
 907         device_t dev;
 908         struct ccb_pathinq *cpi;
 909
 910         dev = sc->vtscsi_dev;
 911         cpi = &ccb->cpi;
 912
 913         vtscsi_dprintf(sc, VTSCSI_TRACE, "sim=%p ccb=%p\n", sim, ccb);
 914
 915         cpi->version_num = 1;
 916         cpi->hba_inquiry = PI_TAG_ABLE;
 917         cpi->target_sprt = 0;
 918         cpi->hba_misc = PIM_SEQSCAN;
 919         if (vtscsi_bus_reset_disable != 0)
 920                 cpi->hba_misc |= PIM_NOBUSRESET;
 921         cpi->hba_eng_cnt = 0;
 922
 923         cpi->max_target = sc->vtscsi_max_target;
 924         cpi->max_lun = sc->vtscsi_max_lun;
 925         cpi->initiator_id = VTSCSI_INITIATOR_ID;
 926
 927         strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
 928         strncpy(cpi->hba_vid, "VirtIO", HBA_IDLEN);
 929         strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
 930
 931         cpi->unit_number = cam_sim_unit(sim);
 932         cpi->bus_id = cam_sim_bus(sim);
 933
 934         cpi->base_transfer_speed = 300000;
 935
 936         cpi->protocol = PROTO_SCSI;
 937         cpi->protocol_version = SCSI_REV_SPC3;
 938         cpi->transport = XPORT_SAS;
 939         cpi->transport_version = 0;
 940
 941         cpi->maxio = (sc->vtscsi_max_nsegs - VTSCSI_MIN_SEGMENTS - 1) *
 942             PAGE_SIZE;
 943
 944         cpi->hba_vendor = virtio_get_vendor(dev);
 945         cpi->hba_device = virtio_get_device(dev);
 946         cpi->hba_subvendor = virtio_get_subvendor(dev);
 947         cpi->hba_subdevice = virtio_get_subdevice(dev);
 948
 949         ccb->ccb_h.status = CAM_REQ_CMP;
 950         xpt_done(ccb);
 951 }
 952
 953 static int
 954 vtscsi_sg_append_scsi_buf(struct vtscsi_softc *sc, struct sglist *sg,
 955     struct ccb_scsiio *csio)
 956 {
 957         struct ccb_hdr *ccbh;
 958         struct bus_dma_segment *dseg;
 959         int i, error;
 960
 961         ccbh = &csio->ccb_h;
 962         error = 0;
 963
 964         switch ((ccbh->flags & CAM_DATA_MASK)) {
 965         case CAM_DATA_VADDR:
 966                 error = sglist_append(sg, csio->data_ptr, csio->dxfer_len);
 967                 break;
 968         case CAM_DATA_PADDR:
 969                 error = sglist_append_phys(sg,
 970                     (vm_paddr_t)(vm_offset_t) csio->data_ptr, csio->dxfer_len);
 971                 break;
 972         case CAM_DATA_SG:
 973                 for (i = 0; i < csio->sglist_cnt && error == 0; i++) {
 974                         dseg = &((struct bus_dma_segment *)csio->data_ptr)[i];
 975                         error = sglist_append(sg,
 976                             (void *)(vm_offset_t) dseg->ds_addr, dseg->ds_len);
 977                 }
 978                 break;
 979         case CAM_DATA_SG_PADDR:
 980                 for (i = 0; i < csio->sglist_cnt && error == 0; i++) {
 981                         dseg = &((struct bus_dma_segment *)csio->data_ptr)[i];
 982                         error = sglist_append_phys(sg,
 983                             (vm_paddr_t) dseg->ds_addr, dseg->ds_len);
 984                 }
 985                 break;
 986         default:
 987                 error = EINVAL;
 988                 break;
 989         }
 990
 991         return (error);
 992 }
 993
 994 static int
 995 vtscsi_fill_scsi_cmd_sglist(struct vtscsi_softc *sc, struct vtscsi_request *req,
 996     int *readable, int *writable)
 997 {
 998         struct sglist *sg;
 999         struct ccb_hdr *ccbh;
1000         struct ccb_scsiio *csio;
1001         struct virtio_scsi_cmd_req *cmd_req;
1002         struct virtio_scsi_cmd_resp *cmd_resp;
1003         int error;
1004
1005         sg = sc->vtscsi_sglist;
1006         csio = &req->vsr_ccb->csio;
1007         ccbh = &csio->ccb_h;
1008         cmd_req = &req->vsr_cmd_req;
1009         cmd_resp = &req->vsr_cmd_resp;
1010
1011         sglist_reset(sg);
1012
1013         sglist_append(sg, cmd_req, sizeof(struct virtio_scsi_cmd_req));
1014         if ((ccbh->flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
1015                 error = vtscsi_sg_append_scsi_buf(sc, sg, csio);
1016                 /* At least one segment must be left for the response. */
1017                 if (error || sg->sg_nseg == sg->sg_maxseg)
1018                         goto fail;
1019         }
1020
1021         *readable = sg->sg_nseg;
1022
1023         sglist_append(sg, cmd_resp, sizeof(struct virtio_scsi_cmd_resp));
1024         if ((ccbh->flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1025                 error = vtscsi_sg_append_scsi_buf(sc, sg, csio);
1026                 if (error)
1027                         goto fail;
1028         }
1029
1030         *writable = sg->sg_nseg - *readable;
1031
1032         vtscsi_dprintf(sc, VTSCSI_TRACE, "req=%p ccb=%p readable=%d "
1033             "writable=%d\n", req, ccbh, *readable, *writable);
1034
1035         return (0);
1036
1037 fail:
1038         /*
1039          * This should never happen unless maxio was incorrectly set.
1040          */
1041         vtscsi_set_ccb_status(ccbh, CAM_REQ_TOO_BIG, 0);
1042
1043         vtscsi_dprintf(sc, VTSCSI_ERROR, "error=%d req=%p ccb=%p "
1044             "nseg=%d maxseg=%d\n",
1045             error, req, ccbh, sg->sg_nseg, sg->sg_maxseg);
1046
1047         return (EFBIG);
1048 }
1049
1050 static int
1051 vtscsi_execute_scsi_cmd(struct vtscsi_softc *sc, struct vtscsi_request *req)
1052 {
1053         struct sglist *sg;
1054         struct virtqueue *vq;
1055         struct ccb_scsiio *csio;
1056         struct ccb_hdr *ccbh;
1057         struct virtio_scsi_cmd_req *cmd_req;
1058         struct virtio_scsi_cmd_resp *cmd_resp;
1059         int readable, writable, error;
1060
1061         sg = sc->vtscsi_sglist;
1062         vq = sc->vtscsi_request_vq;
1063         csio = &req->vsr_ccb->csio;
1064         ccbh = &csio->ccb_h;
1065         cmd_req = &req->vsr_cmd_req;
1066         cmd_resp = &req->vsr_cmd_resp;
1067
1068         vtscsi_init_scsi_cmd_req(csio, cmd_req);
1069
1070         error = vtscsi_fill_scsi_cmd_sglist(sc, req, &readable, &writable);
1071         if (error)
1072                 return (error);
1073
1074         req->vsr_complete = vtscsi_complete_scsi_cmd;
1075         cmd_resp->response = -1;
1076
1077         error = virtqueue_enqueue(vq, req, sg, readable, writable);
1078         if (error) {
1079                 vtscsi_dprintf(sc, VTSCSI_ERROR,
1080                     "enqueue error=%d req=%p ccb=%p\n", error, req, ccbh);
1081
1082                 ccbh->status = CAM_REQUEUE_REQ;
1083                 vtscsi_freeze_simq(sc, VTSCSI_REQUEST_VQ);
1084                 return (error);
1085         }
1086
1087         ccbh->status |= CAM_SIM_QUEUED;
1088         ccbh->ccbh_vtscsi_req = req;
1089
1090         virtqueue_notify(vq);
1091
1092         if (ccbh->timeout != CAM_TIME_INFINITY) {
1093                 req->vsr_flags |= VTSCSI_REQ_FLAG_TIMEOUT_SET;
1094                 callout_reset(&req->vsr_callout, ccbh->timeout * hz / 1000,
1095                     vtscsi_timedout_scsi_cmd, req);
1096         }
1097
1098         vtscsi_dprintf_req(req, VTSCSI_TRACE, "enqueued req=%p ccb=%p\n",
1099             req, ccbh);
1100
1101         return (0);
1102 }
1103
1104 static int
1105 vtscsi_start_scsi_cmd(struct vtscsi_softc *sc, union ccb *ccb)
1106 {
1107         struct vtscsi_request *req;
1108         int error;
1109
1110         req = vtscsi_dequeue_request(sc);
1111         if (req == NULL) {
1112                 ccb->ccb_h.status = CAM_REQUEUE_REQ;
1113                 vtscsi_freeze_simq(sc, VTSCSI_REQUEST);
1114                 return (ENOBUFS);
1115         }
1116
1117         req->vsr_ccb = ccb;
1118
1119         error = vtscsi_execute_scsi_cmd(sc, req);
1120         if (error)
1121                 vtscsi_enqueue_request(sc, req);
1122
1123         return (error);
1124 }
1125
1126 static void
1127 vtscsi_complete_abort_timedout_scsi_cmd(struct vtscsi_softc *sc,
1128     struct vtscsi_request *req)
1129 {
1130         struct virtio_scsi_ctrl_tmf_resp *tmf_resp;
1131         struct vtscsi_request *to_req;
1132         uint8_t response;
1133
1134         tmf_resp = &req->vsr_tmf_resp;
1135         response = tmf_resp->response;
1136         to_req = req->vsr_timedout_req;
1137
1138         vtscsi_dprintf(sc, VTSCSI_TRACE, "req=%p to_req=%p response=%d\n",
1139             req, to_req, response);
1140
1141         vtscsi_enqueue_request(sc, req);
1142
1143         /*
1144          * The timedout request could have completed between when the
1145          * abort task was sent and when the host processed it.
1146          */
1147         if (to_req->vsr_state != VTSCSI_REQ_STATE_TIMEDOUT)
1148                 return;
1149
1150         /* The timedout request was successfully aborted. */
1151         if (response == VIRTIO_SCSI_S_FUNCTION_COMPLETE)
1152                 return;
1153
1154         /* Don't bother if the device is going away. */
1155         if (sc->vtscsi_flags & VTSCSI_FLAG_DETACH)
1156                 return;
1157
1158         /* The timedout request will be aborted by the reset. */
1159         if (sc->vtscsi_flags & VTSCSI_FLAG_RESET)
1160                 return;
1161
1162         vtscsi_reset_bus(sc);
1163 }
1164
1165 static int
1166 vtscsi_abort_timedout_scsi_cmd(struct vtscsi_softc *sc,
1167     struct vtscsi_request *to_req)
1168 {
1169         struct sglist *sg;
1170         struct ccb_hdr *to_ccbh;
1171         struct vtscsi_request *req;
1172         struct virtio_scsi_ctrl_tmf_req *tmf_req;
1173         struct virtio_scsi_ctrl_tmf_resp *tmf_resp;
1174         int error;
1175
1176         sg = sc->vtscsi_sglist;
1177         to_ccbh = &to_req->vsr_ccb->ccb_h;
1178
1179         req = vtscsi_dequeue_request(sc);
1180         if (req == NULL) {
1181                 error = ENOBUFS;
1182                 goto fail;
1183         }
1184
1185         tmf_req = &req->vsr_tmf_req;
1186         tmf_resp = &req->vsr_tmf_resp;
1187
1188         vtscsi_init_ctrl_tmf_req(to_ccbh, VIRTIO_SCSI_T_TMF_ABORT_TASK,
1189             (uintptr_t) to_ccbh, tmf_req);
1190
1191         sglist_reset(sg);
1192         sglist_append(sg, tmf_req, sizeof(struct virtio_scsi_ctrl_tmf_req));
1193         sglist_append(sg, tmf_resp, sizeof(struct virtio_scsi_ctrl_tmf_resp));
1194
1195         req->vsr_timedout_req = to_req;
1196         req->vsr_complete = vtscsi_complete_abort_timedout_scsi_cmd;
1197         tmf_resp->response = -1;
1198
1199         error = vtscsi_execute_ctrl_req(sc, req, sg, 1, 1,
1200             VTSCSI_EXECUTE_ASYNC);
1201         if (error == 0)
1202                 return (0);
1203
1204         vtscsi_enqueue_request(sc, req);
1205
1206 fail:
1207         vtscsi_dprintf(sc, VTSCSI_ERROR, "error=%d req=%p "
1208             "timedout req=%p ccb=%p\n", error, req, to_req, to_ccbh);
1209
1210         return (error);
1211 }
1212
1213 static void
1214 vtscsi_timedout_scsi_cmd(void *xreq)
1215 {
1216         struct vtscsi_softc *sc;
1217         struct vtscsi_request *to_req;
1218
1219         to_req = xreq;
1220         sc = to_req->vsr_softc;
1221
1222         vtscsi_dprintf(sc, VTSCSI_INFO, "timedout req=%p ccb=%p state=%#x\n",
1223             to_req, to_req->vsr_ccb, to_req->vsr_state);
1224
1225         /* Don't bother if the device is going away. */
1226         if (sc->vtscsi_flags & VTSCSI_FLAG_DETACH)
1227                 return;
1228
1229         /*
1230          * Bail if the request is not in use. We likely raced when
1231          * stopping the callout handler or it has already been aborted.
1232          */
1233         if (to_req->vsr_state != VTSCSI_REQ_STATE_INUSE ||
1234             (to_req->vsr_flags & VTSCSI_REQ_FLAG_TIMEOUT_SET) == 0)
1235                 return;
1236
1237         /*
1238          * Complete the request queue in case the timedout request is
1239          * actually just pending.
1240          */
1241         vtscsi_complete_vq(sc, sc->vtscsi_request_vq);
1242         if (to_req->vsr_state == VTSCSI_REQ_STATE_FREE)
1243                 return;
1244
1245         sc->vtscsi_stats.scsi_cmd_timeouts++;
1246         to_req->vsr_state = VTSCSI_REQ_STATE_TIMEDOUT;
1247
1248         if (vtscsi_abort_timedout_scsi_cmd(sc, to_req) == 0)
1249                 return;
1250
1251         vtscsi_dprintf(sc, VTSCSI_ERROR, "resetting bus\n");
1252         vtscsi_reset_bus(sc);
1253 }
1254
1255 static cam_status
1256 vtscsi_scsi_cmd_cam_status(struct virtio_scsi_cmd_resp *cmd_resp)
1257 {
1258         cam_status status;
1259
1260         switch (cmd_resp->response) {
1261         case VIRTIO_SCSI_S_OK:
1262                 status = CAM_REQ_CMP;
1263                 break;
1264         case VIRTIO_SCSI_S_OVERRUN:
1265                 status = CAM_DATA_RUN_ERR;
1266                 break;
1267         case VIRTIO_SCSI_S_ABORTED:
1268                 status = CAM_REQ_ABORTED;
1269                 break;
1270         case VIRTIO_SCSI_S_BAD_TARGET:
1271                 status = CAM_TID_INVALID;
1272                 break;
1273         case VIRTIO_SCSI_S_RESET:
1274                 status = CAM_SCSI_BUS_RESET;
1275                 break;
1276         case VIRTIO_SCSI_S_BUSY:
1277                 status = CAM_SCSI_BUSY;
1278                 break;
1279         case VIRTIO_SCSI_S_TRANSPORT_FAILURE:
1280         case VIRTIO_SCSI_S_TARGET_FAILURE:
1281         case VIRTIO_SCSI_S_NEXUS_FAILURE:
1282                 status = CAM_SCSI_IT_NEXUS_LOST;
1283                 break;
1284         default: /* VIRTIO_SCSI_S_FAILURE */
1285                 status = CAM_REQ_CMP_ERR;
1286                 break;
1287         }
1288
1289         return (status);
1290 }
1291
1292 static cam_status
1293 vtscsi_complete_scsi_cmd_response(struct vtscsi_softc *sc,
1294     struct ccb_scsiio *csio, struct virtio_scsi_cmd_resp *cmd_resp)
1295 {
1296         cam_status status;
1297
1298         csio->scsi_status = cmd_resp->status;
1299         csio->resid = cmd_resp->resid;
1300
1301         if (csio->scsi_status == SCSI_STATUS_OK)
1302                 status = CAM_REQ_CMP;
1303         else
1304                 status = CAM_SCSI_STATUS_ERROR;
1305
1306         if (cmd_resp->sense_len > 0) {
1307                 status |= CAM_AUTOSNS_VALID;
1308
1309                 if (cmd_resp->sense_len < csio->sense_len)
1310                         csio->sense_resid = csio->sense_len -
1311                             cmd_resp->sense_len;
1312                 else
1313                         csio->sense_resid = 0;
1314
1315                 bzero(&csio->sense_data, sizeof(csio->sense_data));
1316                 memcpy(cmd_resp->sense, &csio->sense_data,
1317                     csio->sense_len - csio->sense_resid);
1318         }
1319
1320         vtscsi_dprintf(sc, status == CAM_REQ_CMP ? VTSCSI_TRACE : VTSCSI_ERROR,
1321             "ccb=%p scsi_status=%#x resid=%u sense_resid=%u\n",
1322             csio, csio->scsi_status, csio->resid, csio->sense_resid);
1323
1324         return (status);
1325 }
1326
1327 static void
1328 vtscsi_complete_scsi_cmd(struct vtscsi_softc *sc, struct vtscsi_request *req)
1329 {
1330         struct ccb_hdr *ccbh;
1331         struct ccb_scsiio *csio;
1332         struct virtio_scsi_cmd_resp *cmd_resp;
1333         cam_status status;
1334
1335         csio = &req->vsr_ccb->csio;
1336         ccbh = &csio->ccb_h;
1337         cmd_resp = &req->vsr_cmd_resp;
1338
1339         KASSERT(ccbh->ccbh_vtscsi_req == req,
1340             ("ccb %p req mismatch %p/%p", ccbh, ccbh->ccbh_vtscsi_req, req));
1341
1342         if (req->vsr_flags & VTSCSI_REQ_FLAG_TIMEOUT_SET)
1343                 callout_stop(&req->vsr_callout);
1344
1345         status = vtscsi_scsi_cmd_cam_status(cmd_resp);
1346         if (status == CAM_REQ_ABORTED) {
1347                 if (req->vsr_state == VTSCSI_REQ_STATE_TIMEDOUT)
1348                         status = CAM_CMD_TIMEOUT;
1349         } else if (status == CAM_REQ_CMP)
1350                 status = vtscsi_complete_scsi_cmd_response(sc, csio, cmd_resp);
1351
1352         if ((status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1353                 status |= CAM_DEV_QFRZN;
1354                 xpt_freeze_devq(ccbh->path, 1);
1355         }
1356
1357         if (vtscsi_thaw_simq(sc, VTSCSI_REQUEST | VTSCSI_REQUEST_VQ) != 0)
1358                 status |= CAM_RELEASE_SIMQ;
1359
1360         vtscsi_dprintf(sc, VTSCSI_TRACE, "req=%p ccb=%p status=%#x\n",
1361             req, ccbh, status);
1362
1363         ccbh->status = status;
1364         xpt_done(req->vsr_ccb);
1365         vtscsi_enqueue_request(sc, req);
1366 }
1367
1368 static void
1369 vtscsi_poll_ctrl_req(struct vtscsi_softc *sc, struct vtscsi_request *req)
1370 {
1371
1372         /* XXX We probably shouldn't poll forever. */
1373         req->vsr_flags |= VTSCSI_REQ_FLAG_POLLED;
1374         do
1375                 vtscsi_complete_vq(sc, sc->vtscsi_control_vq);
1376         while ((req->vsr_flags & VTSCSI_REQ_FLAG_COMPLETE) == 0);
1377
1378         req->vsr_flags &= ~VTSCSI_REQ_FLAG_POLLED;
1379 }
1380
1381 static int
1382 vtscsi_execute_ctrl_req(struct vtscsi_softc *sc, struct vtscsi_request *req,
1383     struct sglist *sg, int readable, int writable, int flag)
1384 {
1385         struct virtqueue *vq;
1386         int error;
1387
1388         vq = sc->vtscsi_control_vq;
1389
1390         MPASS(flag == VTSCSI_EXECUTE_POLL || req->vsr_complete != NULL);
1391
1392         error = virtqueue_enqueue(vq, req, sg, readable, writable);
1393         if (error) {
1394                 /*
1395                  * Return EAGAIN when the virtqueue does not have enough
1396                  * descriptors available.
1397                  */
1398                 if (error == ENOSPC || error == EMSGSIZE)
1399                         error = EAGAIN;
1400
1401                 return (error);
1402         }
1403
1404         virtqueue_notify(vq);
1405         if (flag == VTSCSI_EXECUTE_POLL)
1406                 vtscsi_poll_ctrl_req(sc, req);
1407
1408         return (0);
1409 }
1410
1411 static void
1412 vtscsi_complete_abort_task_cmd(struct vtscsi_softc *sc,
1413     struct vtscsi_request *req)
1414 {
1415         union ccb *ccb;
1416         struct ccb_hdr *ccbh;
1417         struct virtio_scsi_ctrl_tmf_resp *tmf_resp;
1418
1419         ccb = req->vsr_ccb;
1420         ccbh = &ccb->ccb_h;
1421         tmf_resp = &req->vsr_tmf_resp;
1422
1423         switch (tmf_resp->response) {
1424         case VIRTIO_SCSI_S_FUNCTION_COMPLETE:
1425                 ccbh->status = CAM_REQ_CMP;
1426                 break;
1427         case VIRTIO_SCSI_S_FUNCTION_REJECTED:
1428                 ccbh->status = CAM_UA_ABORT;
1429                 break;
1430         default:
1431                 ccbh->status = CAM_REQ_CMP_ERR;
1432                 break;
1433         }
1434
1435         xpt_done(ccb);
1436         vtscsi_enqueue_request(sc, req);
1437 }
1438
1439 static int
1440 vtscsi_execute_abort_task_cmd(struct vtscsi_softc *sc,
1441     struct vtscsi_request *req)
1442 {
1443         struct sglist *sg;
1444         struct ccb_abort *cab;
1445         struct ccb_hdr *ccbh;
1446         struct ccb_hdr *abort_ccbh;
1447         struct vtscsi_request *abort_req;
1448         struct virtio_scsi_ctrl_tmf_req *tmf_req;
1449         struct virtio_scsi_ctrl_tmf_resp *tmf_resp;
1450         int error;
1451
1452         sg = sc->vtscsi_sglist;
1453         cab = &req->vsr_ccb->cab;
1454         ccbh = &cab->ccb_h;
1455         tmf_req = &req->vsr_tmf_req;
1456         tmf_resp = &req->vsr_tmf_resp;
1457
1458         /* CCB header and request that's to be aborted. */
1459         abort_ccbh = &cab->abort_ccb->ccb_h;
1460         abort_req = abort_ccbh->ccbh_vtscsi_req;
1461
1462         if (abort_ccbh->func_code != XPT_SCSI_IO || abort_req == NULL) {
1463                 error = EINVAL;
1464                 goto fail;
1465         }
1466
1467         /* Only attempt to abort requests that could be in-flight. */
1468         if (abort_req->vsr_state != VTSCSI_REQ_STATE_INUSE) {
1469                 error = EALREADY;
1470                 goto fail;
1471         }
1472
1473         abort_req->vsr_state = VTSCSI_REQ_STATE_ABORTED;
1474         if (abort_req->vsr_flags & VTSCSI_REQ_FLAG_TIMEOUT_SET)
1475                 callout_stop(&abort_req->vsr_callout);
1476
1477         vtscsi_init_ctrl_tmf_req(ccbh, VIRTIO_SCSI_T_TMF_ABORT_TASK,
1478             (uintptr_t) abort_ccbh, tmf_req);
1479
1480         sglist_reset(sg);
1481         sglist_append(sg, tmf_req, sizeof(struct virtio_scsi_ctrl_tmf_req));
1482         sglist_append(sg, tmf_resp, sizeof(struct virtio_scsi_ctrl_tmf_resp));
1483
1484         req->vsr_complete = vtscsi_complete_abort_task_cmd;
1485         tmf_resp->response = -1;
1486
1487         error = vtscsi_execute_ctrl_req(sc, req, sg, 1, 1,
1488             VTSCSI_EXECUTE_ASYNC);
1489
1490 fail:
1491         vtscsi_dprintf(sc, VTSCSI_TRACE, "error=%d req=%p abort_ccb=%p "
1492             "abort_req=%p\n", error, req, abort_ccbh, abort_req);
1493
1494         return (error);
1495 }
1496
1497 static void
1498 vtscsi_complete_reset_dev_cmd(struct vtscsi_softc *sc,
1499     struct vtscsi_request *req)
1500 {
1501         union ccb *ccb;
1502         struct ccb_hdr *ccbh;
1503         struct virtio_scsi_ctrl_tmf_resp *tmf_resp;
1504
1505         ccb = req->vsr_ccb;
1506         ccbh = &ccb->ccb_h;
1507         tmf_resp = &req->vsr_tmf_resp;
1508
1509         vtscsi_dprintf(sc, VTSCSI_TRACE, "req=%p ccb=%p response=%d\n",
1510             req, ccb, tmf_resp->response);
1511
1512         if (tmf_resp->response == VIRTIO_SCSI_S_FUNCTION_COMPLETE) {
1513                 ccbh->status = CAM_REQ_CMP;
1514                 vtscsi_announce(sc, AC_SENT_BDR, ccbh->target_id,
1515                     ccbh->target_lun);
1516         } else
1517                 ccbh->status = CAM_REQ_CMP_ERR;
1518
1519         xpt_done(ccb);
1520         vtscsi_enqueue_request(sc, req);
1521 }
1522
1523 static int
1524 vtscsi_execute_reset_dev_cmd(struct vtscsi_softc *sc,
1525     struct vtscsi_request *req)
1526 {
1527         struct sglist *sg;
1528         struct ccb_resetdev *crd;
1529         struct ccb_hdr *ccbh;
1530         struct virtio_scsi_ctrl_tmf_req *tmf_req;
1531         struct virtio_scsi_ctrl_tmf_resp *tmf_resp;
1532         uint32_t subtype;
1533         int error;
1534
1535         sg = sc->vtscsi_sglist;
1536         crd = &req->vsr_ccb->crd;
1537         ccbh = &crd->ccb_h;
1538         tmf_req = &req->vsr_tmf_req;
1539         tmf_resp = &req->vsr_tmf_resp;
1540
1541         if (ccbh->target_lun == CAM_LUN_WILDCARD)
1542                 subtype = VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET;
1543         else
1544                 subtype = VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET;
1545
1546         vtscsi_init_ctrl_tmf_req(ccbh, subtype, 0, tmf_req);
1547
1548         sglist_reset(sg);
1549         sglist_append(sg, tmf_req, sizeof(struct virtio_scsi_ctrl_tmf_req));
1550         sglist_append(sg, tmf_resp, sizeof(struct virtio_scsi_ctrl_tmf_resp));
1551
1552         req->vsr_complete = vtscsi_complete_reset_dev_cmd;
1553         tmf_resp->response = -1;
1554
1555         error = vtscsi_execute_ctrl_req(sc, req, sg, 1, 1,
1556             VTSCSI_EXECUTE_ASYNC);
1557
1558         vtscsi_dprintf(sc, VTSCSI_TRACE, "error=%d req=%p ccb=%p\n",
1559             error, req, ccbh);
1560
1561         return (error);
1562 }
1563
1564 static void
1565 vtscsi_get_request_lun(uint8_t lun[], target_id_t *target_id, lun_id_t *lun_id)
1566 {
1567
1568         *target_id = lun[1];
1569         *lun_id = (lun[2] << 8) | lun[3];
1570 }
1571
1572 static void
1573 vtscsi_set_request_lun(struct ccb_hdr *ccbh, uint8_t lun[])
1574 {
1575
1576         lun[0] = 1;
1577         lun[1] = ccbh->target_id;
1578         lun[2] = 0x40 | ((ccbh->target_lun >> 8) & 0x3F);
1579         lun[3] = (ccbh->target_lun >> 8) & 0xFF;
1580 }
1581
1582 static void
1583 vtscsi_init_scsi_cmd_req(struct ccb_scsiio *csio,
1584     struct virtio_scsi_cmd_req *cmd_req)
1585 {
1586         uint8_t attr;
1587
1588         switch (csio->tag_action) {
1589         case MSG_HEAD_OF_Q_TAG:
1590                 attr = VIRTIO_SCSI_S_HEAD;
1591                 break;
1592         case MSG_ORDERED_Q_TAG:
1593                 attr = VIRTIO_SCSI_S_ORDERED;
1594                 break;
1595         case MSG_ACA_TASK:
1596                 attr = VIRTIO_SCSI_S_ACA;
1597                 break;
1598         default: /* MSG_SIMPLE_Q_TAG */
1599                 attr = VIRTIO_SCSI_S_SIMPLE;
1600                 break;
1601         }
1602
1603         vtscsi_set_request_lun(&csio->ccb_h, cmd_req->lun);
1604         cmd_req->tag = (uintptr_t) csio;
1605         cmd_req->task_attr = attr;
1606
1607         memcpy(cmd_req->cdb,
1608             csio->ccb_h.flags & CAM_CDB_POINTER ?
1609                 csio->cdb_io.cdb_ptr : csio->cdb_io.cdb_bytes,
1610             csio->cdb_len);
1611 }
1612
1613 static void
1614 vtscsi_init_ctrl_tmf_req(struct ccb_hdr *ccbh, uint32_t subtype,
1615     uintptr_t tag, struct virtio_scsi_ctrl_tmf_req *tmf_req)
1616 {
1617
1618         vtscsi_set_request_lun(ccbh, tmf_req->lun);
1619
1620         tmf_req->type = VIRTIO_SCSI_T_TMF;
1621         tmf_req->subtype = subtype;
1622         tmf_req->tag = tag;
1623 }
1624
1625 static void
1626 vtscsi_freeze_simq(struct vtscsi_softc *sc, int reason)
1627 {
1628         int frozen;
1629
1630         frozen = sc->vtscsi_frozen;
1631
1632         if (reason & VTSCSI_REQUEST &&
1633             (sc->vtscsi_frozen & VTSCSI_FROZEN_NO_REQUESTS) == 0)
1634                 sc->vtscsi_frozen |= VTSCSI_FROZEN_NO_REQUESTS;
1635
1636         if (reason & VTSCSI_REQUEST_VQ &&
1637             (sc->vtscsi_frozen & VTSCSI_FROZEN_REQUEST_VQ_FULL) == 0)
1638                 sc->vtscsi_frozen |= VTSCSI_FROZEN_REQUEST_VQ_FULL;
1639
1640         /* Freeze the SIMQ if transitioned to frozen. */
1641         if (frozen == 0 && sc->vtscsi_frozen != 0) {
1642                 vtscsi_dprintf(sc, VTSCSI_INFO, "SIMQ frozen\n");
1643                 xpt_freeze_simq(sc->vtscsi_sim, 1);
1644         }
1645 }
1646
1647 static int
1648 vtscsi_thaw_simq(struct vtscsi_softc *sc, int reason)
1649 {
1650         int thawed;
1651
1652         if (sc->vtscsi_frozen == 0 || reason == 0)
1653                 return (0);
1654
1655         if (reason & VTSCSI_REQUEST &&
1656             sc->vtscsi_frozen & VTSCSI_FROZEN_NO_REQUESTS)
1657                 sc->vtscsi_frozen &= ~VTSCSI_FROZEN_NO_REQUESTS;
1658
1659         if (reason & VTSCSI_REQUEST_VQ &&
1660             sc->vtscsi_frozen & VTSCSI_FROZEN_REQUEST_VQ_FULL)
1661                 sc->vtscsi_frozen &= ~VTSCSI_FROZEN_REQUEST_VQ_FULL;
1662
1663         thawed = sc->vtscsi_frozen == 0;
1664         if (thawed != 0)
1665                 vtscsi_dprintf(sc, VTSCSI_INFO, "SIMQ thawed\n");
1666
1667         return (thawed);
1668 }
1669
1670 static void
1671 vtscsi_announce(struct vtscsi_softc *sc, uint32_t ac_code,
1672     target_id_t target_id, lun_id_t lun_id)
1673 {
1674         struct cam_path *path;
1675
1676         /* Use the wildcard path from our softc for bus announcements. */
1677         if (target_id == CAM_TARGET_WILDCARD && lun_id == CAM_LUN_WILDCARD) {
1678                 xpt_async(ac_code, sc->vtscsi_path, NULL);
1679                 return;
1680         }
1681
1682         if (xpt_create_path(&path, NULL, cam_sim_path(sc->vtscsi_sim),
1683             target_id, lun_id) != CAM_REQ_CMP) {
1684                 vtscsi_dprintf(sc, VTSCSI_ERROR, "cannot create path\n");
1685                 return;
1686         }
1687
1688         xpt_async(ac_code, path, NULL);
1689         xpt_free_path(path);
1690 }
1691
1692 static void
1693 vtscsi_execute_rescan(struct vtscsi_softc *sc, target_id_t target_id,
1694     lun_id_t lun_id)
1695 {
1696         union ccb *ccb;
1697         cam_status status;
1698
1699         ccb = xpt_alloc_ccb_nowait();
1700         if (ccb == NULL) {
1701                 vtscsi_dprintf(sc, VTSCSI_ERROR, "cannot allocate CCB\n");
1702                 return;
1703         }
1704
1705         status = xpt_create_path(&ccb->ccb_h.path, NULL,
1706             cam_sim_path(sc->vtscsi_sim), target_id, lun_id);
1707         if (status != CAM_REQ_CMP) {
1708                 xpt_free_ccb(ccb);
1709                 return;
1710         }
1711
1712         xpt_rescan(ccb);
1713 }
1714
1715 static void
1716 vtscsi_execute_rescan_bus(struct vtscsi_softc *sc)
1717 {
1718
1719         vtscsi_execute_rescan(sc, CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
1720 }
1721
1722 static void
1723 vtscsi_transport_reset_event(struct vtscsi_softc *sc,
1724     struct virtio_scsi_event *event)
1725 {
1726         target_id_t target_id;
1727         lun_id_t lun_id;
1728
1729         vtscsi_get_request_lun(event->lun, &target_id, &lun_id);
1730
1731         switch (event->reason) {
1732         case VIRTIO_SCSI_EVT_RESET_RESCAN:
1733         case VIRTIO_SCSI_EVT_RESET_REMOVED:
1734                 vtscsi_execute_rescan(sc, target_id, lun_id);
1735                 break;
1736         default:
1737                 device_printf(sc->vtscsi_dev,
1738                     "unhandled transport event reason: %d\n", event->reason);
1739                 break;
1740         }
1741 }
1742
1743 static void
1744 vtscsi_handle_event(struct vtscsi_softc *sc, struct virtio_scsi_event *event)
1745 {
1746         int error;
1747
1748         if ((event->event & VIRTIO_SCSI_T_EVENTS_MISSED) == 0) {
1749                 switch (event->event) {
1750                 case VIRTIO_SCSI_T_TRANSPORT_RESET:
1751                         vtscsi_transport_reset_event(sc, event);
1752                         break;
1753                 default:
1754                         device_printf(sc->vtscsi_dev,
1755                             "unhandled event: %d\n", event->event);
1756                         break;
1757                 }
1758         } else
1759                 vtscsi_execute_rescan_bus(sc);
1760
1761         /*
1762          * This should always be successful since the buffer
1763          * was just dequeued.
1764          */
1765         error = vtscsi_enqueue_event_buf(sc, event);
1766         KASSERT(error == 0,
1767             ("cannot requeue event buffer: %d", error));
1768 }
1769
1770 static int
1771 vtscsi_enqueue_event_buf(struct vtscsi_softc *sc,
1772     struct virtio_scsi_event *event)
1773 {
1774         struct sglist *sg;
1775         struct virtqueue *vq;
1776         int size, error;
1777
1778         sg = sc->vtscsi_sglist;
1779         vq = sc->vtscsi_event_vq;
1780         size = sc->vtscsi_event_buf_size;
1781
1782         bzero(event, size);
1783
1784         sglist_reset(sg);
1785         error = sglist_append(sg, event, size);
1786         if (error)
1787                 return (error);
1788
1789         error = virtqueue_enqueue(vq, event, sg, 0, sg->sg_nseg);
1790         if (error)
1791                 return (error);
1792
1793         virtqueue_notify(vq);
1794
1795         return (0);
1796 }
1797
1798 static int
1799 vtscsi_init_event_vq(struct vtscsi_softc *sc)
1800 {
1801         struct virtio_scsi_event *event;
1802         int i, size, error;
1803
1804         /*
1805          * The first release of QEMU with VirtIO SCSI support would crash
1806          * when attempting to notify the event virtqueue. This was fixed
1807          * when hotplug support was added.
1808          */
1809         if (sc->vtscsi_flags & VTSCSI_FLAG_HOTPLUG)
1810                 size = sc->vtscsi_event_buf_size;
1811         else
1812                 size = 0;
1813
1814         if (size < sizeof(struct virtio_scsi_event))
1815                 return (0);
1816
1817         for (i = 0; i < VTSCSI_NUM_EVENT_BUFS; i++) {
1818                 event = &sc->vtscsi_event_bufs[i];
1819
1820                 error = vtscsi_enqueue_event_buf(sc, event);
1821                 if (error)
1822                         break;
1823         }
1824
1825         /*
1826          * Even just one buffer is enough. Missed events are
1827          * denoted with the VIRTIO_SCSI_T_EVENTS_MISSED flag.
1828          */
1829         if (i > 0)
1830                 error = 0;
1831
1832         return (error);
1833 }
1834
1835 static void
1836 vtscsi_reinit_event_vq(struct vtscsi_softc *sc)
1837 {
1838         struct virtio_scsi_event *event;
1839         int i, error;
1840
1841         if ((sc->vtscsi_flags & VTSCSI_FLAG_HOTPLUG) == 0 ||
1842             sc->vtscsi_event_buf_size < sizeof(struct virtio_scsi_event))
1843                 return;
1844
1845         for (i = 0; i < VTSCSI_NUM_EVENT_BUFS; i++) {
1846                 event = &sc->vtscsi_event_bufs[i];
1847
1848                 error = vtscsi_enqueue_event_buf(sc, event);
1849                 if (error)
1850                         break;
1851         }
1852
1853         KASSERT(i > 0, ("cannot reinit event vq: %d", error));
1854 }
1855
1856 static void
1857 vtscsi_drain_event_vq(struct vtscsi_softc *sc)
1858 {
1859         struct virtqueue *vq;
1860         int last;
1861
1862         vq = sc->vtscsi_event_vq;
1863         last = 0;
1864
1865         while (virtqueue_drain(vq, &last) != NULL)
1866                 ;
1867
1868         KASSERT(virtqueue_empty(vq), ("eventvq not empty"));
1869 }
1870
1871 static void
1872 vtscsi_complete_vqs_locked(struct vtscsi_softc *sc)
1873 {
1874
1875         VTSCSI_LOCK_OWNED(sc);
1876
1877         if (sc->vtscsi_request_vq != NULL)
1878                 vtscsi_complete_vq(sc, sc->vtscsi_request_vq);
1879         if (sc->vtscsi_control_vq != NULL)
1880                 vtscsi_complete_vq(sc, sc->vtscsi_control_vq);
1881 }
1882
1883 static void
1884 vtscsi_complete_vqs(struct vtscsi_softc *sc)
1885 {
1886
1887         VTSCSI_LOCK(sc);
1888         vtscsi_complete_vqs_locked(sc);
1889         VTSCSI_UNLOCK(sc);
1890 }
1891
1892 static void
1893 vtscsi_cancel_request(struct vtscsi_softc *sc, struct vtscsi_request *req)
1894 {
1895         union ccb *ccb;
1896         int detach;
1897
1898         ccb = req->vsr_ccb;
1899
1900         vtscsi_dprintf(sc, VTSCSI_TRACE, "req=%p ccb=%p\n", req, ccb);
1901
1902         /*
1903          * The callout must be drained when detaching since the request is
1904          * about to be freed. The VTSCSI_MTX must not be held for this in
1905          * case the callout is pending because there is a deadlock potential.
1906          * Otherwise, the virtqueue is being drained because of a bus reset
1907          * so we only need to attempt to stop the callouts.
1908          */
1909         detach = (sc->vtscsi_flags & VTSCSI_FLAG_DETACH) != 0;
1910         if (detach != 0)
1911                 VTSCSI_LOCK_NOTOWNED(sc);
1912         else
1913                 VTSCSI_LOCK_OWNED(sc);
1914
1915         if (req->vsr_flags & VTSCSI_REQ_FLAG_TIMEOUT_SET) {
1916                 if (detach != 0)
1917                         callout_drain(&req->vsr_callout);
1918                 else
1919                         callout_stop(&req->vsr_callout);
1920         }
1921
1922         if (ccb != NULL) {
1923                 if (detach != 0) {
1924                         VTSCSI_LOCK(sc);
1925                         ccb->ccb_h.status = CAM_NO_HBA;
1926                 } else
1927                         ccb->ccb_h.status = CAM_REQUEUE_REQ;
1928                 xpt_done(ccb);
1929                 if (detach != 0)
1930                         VTSCSI_UNLOCK(sc);
1931         }
1932
1933         vtscsi_enqueue_request(sc, req);
1934 }
1935
1936 static void
1937 vtscsi_drain_vq(struct vtscsi_softc *sc, struct virtqueue *vq)
1938 {
1939         struct vtscsi_request *req;
1940         int last;
1941
1942         last = 0;
1943
1944         vtscsi_dprintf(sc, VTSCSI_TRACE, "vq=%p\n", vq);
1945
1946         while ((req = virtqueue_drain(vq, &last)) != NULL)
1947                 vtscsi_cancel_request(sc, req);
1948
1949         KASSERT(virtqueue_empty(vq), ("virtqueue not empty"));
1950 }
1951
1952 static void
1953 vtscsi_drain_vqs(struct vtscsi_softc *sc)
1954 {
1955
1956         if (sc->vtscsi_control_vq != NULL)
1957                 vtscsi_drain_vq(sc, sc->vtscsi_control_vq);
1958         if (sc->vtscsi_request_vq != NULL)
1959                 vtscsi_drain_vq(sc, sc->vtscsi_request_vq);
1960         if (sc->vtscsi_event_vq != NULL)
1961                 vtscsi_drain_event_vq(sc);
1962 }
1963
1964 static void
1965 vtscsi_stop(struct vtscsi_softc *sc)
1966 {
1967
1968         vtscsi_disable_vqs_intr(sc);
1969         virtio_stop(sc->vtscsi_dev);
1970 }
1971
1972 static int
1973 vtscsi_reset_bus(struct vtscsi_softc *sc)
1974 {
1975         int error;
1976
1977         VTSCSI_LOCK_OWNED(sc);
1978
1979         if (vtscsi_bus_reset_disable != 0) {
1980                 device_printf(sc->vtscsi_dev, "bus reset disabled\n");
1981                 return (0);
1982         }
1983
1984         sc->vtscsi_flags |= VTSCSI_FLAG_RESET;
1985
1986         /*
1987          * vtscsi_stop() will cause the in-flight requests to be canceled.
1988          * Those requests are then completed here so CAM will retry them
1989          * after the reset is complete.
1990          */
1991         vtscsi_stop(sc);
1992         vtscsi_complete_vqs_locked(sc);
1993
1994         /* Rid the virtqueues of any remaining requests. */
1995         vtscsi_drain_vqs(sc);
1996
1997         /*
1998          * Any resource shortage that froze the SIMQ cannot persist across
1999          * a bus reset so ensure it gets thawed here.
2000          */
2001         if (vtscsi_thaw_simq(sc, VTSCSI_REQUEST | VTSCSI_REQUEST_VQ) != 0)
2002                 xpt_release_simq(sc->vtscsi_sim, 0);
2003
2004         error = vtscsi_reinit(sc);
2005         if (error) {
2006                 device_printf(sc->vtscsi_dev,
2007                     "reinitialization failed, stopping device...\n");
2008                 vtscsi_stop(sc);
2009         } else
2010                 vtscsi_announce(sc, AC_BUS_RESET, CAM_TARGET_WILDCARD,
2011                     CAM_LUN_WILDCARD);
2012
2013         sc->vtscsi_flags &= ~VTSCSI_FLAG_RESET;
2014
2015         return (error);
2016 }
2017
2018 static void
2019 vtscsi_init_request(struct vtscsi_softc *sc, struct vtscsi_request *req)
2020 {
2021
2022 #ifdef INVARIANTS
2023         int req_nsegs, resp_nsegs;
2024
2025         req_nsegs = sglist_count(&req->vsr_ureq, sizeof(req->vsr_ureq));
2026         resp_nsegs = sglist_count(&req->vsr_uresp, sizeof(req->vsr_uresp));
2027
2028         KASSERT(req_nsegs == 1, ("request crossed page boundary"));
2029         KASSERT(resp_nsegs == 1, ("response crossed page boundary"));
2030 #endif
2031
2032         req->vsr_softc = sc;
2033         callout_init_mtx(&req->vsr_callout, VTSCSI_MTX(sc), 0);
2034 }
2035
2036 static int
2037 vtscsi_alloc_requests(struct vtscsi_softc *sc)
2038 {
2039         struct vtscsi_request *req;
2040         int i, nreqs;
2041
2042         /*
2043          * Commands destined for either the request or control queues come
2044          * from the same SIM queue. Use the size of the request virtqueue
2045          * as it (should) be much more frequently used. Some additional
2046          * requests are allocated for internal (TMF) use.
2047          */
2048         nreqs = virtqueue_size(sc->vtscsi_request_vq);
2049         if ((sc->vtscsi_flags & VTSCSI_FLAG_INDIRECT) == 0)
2050                 nreqs /= VTSCSI_MIN_SEGMENTS;
2051         nreqs += VTSCSI_RESERVED_REQUESTS;
2052
2053         for (i = 0; i < nreqs; i++) {
2054                 req = malloc(sizeof(struct vtscsi_request), M_DEVBUF,
2055                     M_NOWAIT);
2056                 if (req == NULL)
2057                         return (ENOMEM);
2058
2059                 vtscsi_init_request(sc, req);
2060
2061                 sc->vtscsi_nrequests++;
2062                 vtscsi_enqueue_request(sc, req);
2063         }
2064
2065         return (0);
2066 }
2067
2068 static void
2069 vtscsi_free_requests(struct vtscsi_softc *sc)
2070 {
2071         struct vtscsi_request *req;
2072
2073         while ((req = vtscsi_dequeue_request(sc)) != NULL) {
2074                 KASSERT(callout_active(&req->vsr_callout) == 0,
2075                     ("request callout still active"));
2076
2077                 sc->vtscsi_nrequests--;
2078                 free(req, M_DEVBUF);
2079         }
2080
2081         KASSERT(sc->vtscsi_nrequests == 0, ("leaked requests: %d",
2082             sc->vtscsi_nrequests));
2083 }
2084
2085 static void
2086 vtscsi_enqueue_request(struct vtscsi_softc *sc, struct vtscsi_request *req)
2087 {
2088
2089         KASSERT(req->vsr_softc == sc,
2090             ("non-matching request vsr_softc %p/%p", req->vsr_softc, sc));
2091
2092         vtscsi_dprintf(sc, VTSCSI_TRACE, "req=%p\n", req);
2093
2094         /* A request is available so the SIMQ could be released. */
2095         if (vtscsi_thaw_simq(sc, VTSCSI_REQUEST) != 0)
2096                 xpt_release_simq(sc->vtscsi_sim, 1);
2097
2098         req->vsr_ccb = NULL;
2099         req->vsr_complete = NULL;
2100         req->vsr_ptr0 = NULL;
2101         req->vsr_state = VTSCSI_REQ_STATE_FREE;
2102         req->vsr_flags = 0;
2103
2104         bzero(&req->vsr_ureq, sizeof(req->vsr_ureq));
2105         bzero(&req->vsr_uresp, sizeof(req->vsr_uresp));
2106
2107         /*
2108          * We insert at the tail of the queue in order to make it
2109          * very unlikely a request will be reused if we race with
2110          * stopping its callout handler.
2111          */
2112         TAILQ_INSERT_TAIL(&sc->vtscsi_req_free, req, vsr_link);
2113 }
2114
2115 static struct vtscsi_request *
2116 vtscsi_dequeue_request(struct vtscsi_softc *sc)
2117 {
2118         struct vtscsi_request *req;
2119
2120         req = TAILQ_FIRST(&sc->vtscsi_req_free);
2121         if (req != NULL) {
2122                 req->vsr_state = VTSCSI_REQ_STATE_INUSE;
2123                 TAILQ_REMOVE(&sc->vtscsi_req_free, req, vsr_link);
2124         } else
2125                 sc->vtscsi_stats.dequeue_no_requests++;
2126
2127         vtscsi_dprintf(sc, VTSCSI_TRACE, "req=%p\n", req);
2128
2129         return (req);
2130 }
2131
2132 static void
2133 vtscsi_complete_request(struct vtscsi_request *req)
2134 {
2135
2136         if (req->vsr_flags & VTSCSI_REQ_FLAG_POLLED)
2137                 req->vsr_flags |= VTSCSI_REQ_FLAG_COMPLETE;
2138
2139         if (req->vsr_complete != NULL)
2140                 req->vsr_complete(req->vsr_softc, req);
2141 }
2142
2143 static void
2144 vtscsi_complete_vq(struct vtscsi_softc *sc, struct virtqueue *vq)
2145 {
2146         struct vtscsi_request *req;
2147
2148         VTSCSI_LOCK_OWNED(sc);
2149
2150         while ((req = virtqueue_dequeue(vq, NULL)) != NULL)
2151                 vtscsi_complete_request(req);
2152 }
2153
2154 static void
2155 vtscsi_control_vq_task(void *arg, int pending)
2156 {
2157         struct vtscsi_softc *sc;
2158         struct virtqueue *vq;
2159
2160         sc = arg;
2161         vq = sc->vtscsi_control_vq;
2162
2163         VTSCSI_LOCK(sc);
2164
2165         vtscsi_complete_vq(sc, sc->vtscsi_control_vq);
2166
2167         if (virtqueue_enable_intr(vq) != 0) {
2168                 virtqueue_disable_intr(vq);
2169                 VTSCSI_UNLOCK(sc);
2170                 taskqueue_enqueue_fast(sc->vtscsi_tq,
2171                     &sc->vtscsi_control_intr_task);
2172                 return;
2173         }
2174
2175         VTSCSI_UNLOCK(sc);
2176 }
2177
2178 static void
2179 vtscsi_event_vq_task(void *arg, int pending)
2180 {
2181         struct vtscsi_softc *sc;
2182         struct virtqueue *vq;
2183         struct virtio_scsi_event *event;
2184
2185         sc = arg;
2186         vq = sc->vtscsi_event_vq;
2187
2188         VTSCSI_LOCK(sc);
2189
2190         while ((event = virtqueue_dequeue(vq, NULL)) != NULL)
2191                 vtscsi_handle_event(sc, event);
2192
2193         if (virtqueue_enable_intr(vq) != 0) {
2194                 virtqueue_disable_intr(vq);
2195                 VTSCSI_UNLOCK(sc);
2196                 taskqueue_enqueue_fast(sc->vtscsi_tq,
2197                     &sc->vtscsi_control_intr_task);
2198                 return;
2199         }
2200
2201         VTSCSI_UNLOCK(sc);
2202 }
2203
2204 static void
2205 vtscsi_request_vq_task(void *arg, int pending)
2206 {
2207         struct vtscsi_softc *sc;
2208         struct virtqueue *vq;
2209
2210         sc = arg;
2211         vq = sc->vtscsi_request_vq;
2212
2213         VTSCSI_LOCK(sc);
2214
2215         vtscsi_complete_vq(sc, sc->vtscsi_request_vq);
2216
2217         if (virtqueue_enable_intr(vq) != 0) {
2218                 virtqueue_disable_intr(vq);
2219                 VTSCSI_UNLOCK(sc);
2220                 taskqueue_enqueue_fast(sc->vtscsi_tq,
2221                     &sc->vtscsi_request_intr_task);
2222                 return;
2223         }
2224
2225         VTSCSI_UNLOCK(sc);
2226 }
2227
2228 static int
2229 vtscsi_control_vq_intr(void *xsc)
2230 {
2231         struct vtscsi_softc *sc;
2232
2233         sc = xsc;
2234
2235         virtqueue_disable_intr(sc->vtscsi_control_vq);
2236         taskqueue_enqueue_fast(sc->vtscsi_tq,
2237             &sc->vtscsi_control_intr_task);
2238
2239         return (1);
2240 }
2241
2242 static int
2243 vtscsi_event_vq_intr(void *xsc)
2244 {
2245         struct vtscsi_softc *sc;
2246
2247         sc = xsc;
2248
2249         virtqueue_disable_intr(sc->vtscsi_event_vq);
2250         taskqueue_enqueue_fast(sc->vtscsi_tq,
2251             &sc->vtscsi_event_intr_task);
2252
2253         return (1);
2254 }
2255
2256 static int
2257 vtscsi_request_vq_intr(void *xsc)
2258 {
2259         struct vtscsi_softc *sc;
2260
2261         sc = xsc;
2262
2263         virtqueue_disable_intr(sc->vtscsi_request_vq);
2264         taskqueue_enqueue_fast(sc->vtscsi_tq,
2265             &sc->vtscsi_request_intr_task);
2266
2267         return (1);
2268 }
2269
2270 static void
2271 vtscsi_disable_vqs_intr(struct vtscsi_softc *sc)
2272 {
2273
2274         virtqueue_disable_intr(sc->vtscsi_control_vq);
2275         virtqueue_disable_intr(sc->vtscsi_event_vq);
2276         virtqueue_disable_intr(sc->vtscsi_request_vq);
2277 }
2278
2279 static void
2280 vtscsi_enable_vqs_intr(struct vtscsi_softc *sc)
2281 {
2282
2283         virtqueue_enable_intr(sc->vtscsi_control_vq);
2284         virtqueue_enable_intr(sc->vtscsi_event_vq);
2285         virtqueue_enable_intr(sc->vtscsi_request_vq);
2286 }
2287
2288 static void
2289 vtscsi_get_tunables(struct vtscsi_softc *sc)
2290 {
2291         char tmpstr[64];
2292
2293         TUNABLE_INT_FETCH("hw.vtscsi.debug_level", &sc->vtscsi_debug);
2294
2295         snprintf(tmpstr, sizeof(tmpstr), "dev.vtscsi.%d.debug_level",
2296             device_get_unit(sc->vtscsi_dev));
2297         TUNABLE_INT_FETCH(tmpstr, &sc->vtscsi_debug);
2298 }
2299
2300 static void
2301 vtscsi_add_sysctl(struct vtscsi_softc *sc)
2302 {
2303         device_t dev;
2304         struct vtscsi_statistics *stats;
2305         struct sysctl_ctx_list *ctx;
2306         struct sysctl_oid *tree;
2307         struct sysctl_oid_list *child;
2308
2309         dev = sc->vtscsi_dev;
2310         stats = &sc->vtscsi_stats;
2311         ctx = device_get_sysctl_ctx(dev);
2312         tree = device_get_sysctl_tree(dev);
2313         child = SYSCTL_CHILDREN(tree);
2314
2315         SYSCTL_ADD_INT(ctx, child, OID_AUTO, "debug_level",
2316             CTLFLAG_RW, &sc->vtscsi_debug, 0,
2317             "Debug level");
2318
2319         SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "scsi_cmd_timeouts",
2320             CTLFLAG_RD, &stats->scsi_cmd_timeouts,
2321             "SCSI command timeouts");
2322         SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dequeue_no_requests",
2323             CTLFLAG_RD, &stats->dequeue_no_requests,
2324             "No available requests to dequeue");
2325 }
2326
2327 static void
2328 vtscsi_printf_req(struct vtscsi_request *req, const char *func,
2329     const char *fmt, ...)
2330 {
2331         struct vtscsi_softc *sc;
2332         union ccb *ccb;
2333         struct sbuf sb;
2334         va_list ap;
2335         char str[192];
2336         char path_str[64];
2337
2338         if (req == NULL)
2339                 return;
2340
2341         sc = req->vsr_softc;
2342         ccb = req->vsr_ccb;
2343
2344         va_start(ap, fmt);
2345         sbuf_new(&sb, str, sizeof(str), 0);
2346
2347         if (ccb == NULL) {
2348                 sbuf_printf(&sb, "(noperiph:%s%d:%u): ",
2349                     cam_sim_name(sc->vtscsi_sim), cam_sim_unit(sc->vtscsi_sim),
2350                     cam_sim_bus(sc->vtscsi_sim));
2351         } else {
2352                 xpt_path_string(ccb->ccb_h.path, path_str, sizeof(path_str));
2353                 sbuf_cat(&sb, path_str);
2354                 if (ccb->ccb_h.func_code == XPT_SCSI_IO) {
2355                         scsi_command_string(&ccb->csio, &sb);
2356                         sbuf_printf(&sb, "length %d ", ccb->csio.dxfer_len);
2357                 }
2358         }
2359
2360         sbuf_vprintf(&sb, fmt, ap);
2361         va_end(ap);
2362
2363         sbuf_finish(&sb);
2364         printf("%s: %s: %s", device_get_nameunit(sc->vtscsi_dev), func,
2365             sbuf_data(&sb));
2366 }