sys/dev/virtio/scsi/virtio_scsi.c

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