linux/drivers/scsi/storvsc_drv.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (c) 2009, Microsoft Corporation.
   4 *
   5 * Authors:
   6 *   Haiyang Zhang <haiyangz@microsoft.com>
   7 *   Hank Janssen  <hjanssen@microsoft.com>
   8 *   K. Y. Srinivasan <kys@microsoft.com>
   9 */
  10
  11#include <linux/kernel.h>
  12#include <linux/wait.h>
  13#include <linux/sched.h>
  14#include <linux/completion.h>
  15#include <linux/string.h>
  16#include <linux/mm.h>
  17#include <linux/delay.h>
  18#include <linux/init.h>
  19#include <linux/slab.h>
  20#include <linux/module.h>
  21#include <linux/device.h>
  22#include <linux/hyperv.h>
  23#include <linux/blkdev.h>
  24#include <scsi/scsi.h>
  25#include <scsi/scsi_cmnd.h>
  26#include <scsi/scsi_host.h>
  27#include <scsi/scsi_device.h>
  28#include <scsi/scsi_tcq.h>
  29#include <scsi/scsi_eh.h>
  30#include <scsi/scsi_devinfo.h>
  31#include <scsi/scsi_dbg.h>
  32#include <scsi/scsi_transport_fc.h>
  33#include <scsi/scsi_transport.h>
  34
  35/*
  36 * All wire protocol details (storage protocol between the guest and the host)
  37 * are consolidated here.
  38 *
  39 * Begin protocol definitions.
  40 */
  41
  42/*
  43 * Version history:
  44 * V1 Beta: 0.1
  45 * V1 RC < 2008/1/31: 1.0
  46 * V1 RC > 2008/1/31:  2.0
  47 * Win7: 4.2
  48 * Win8: 5.1
  49 * Win8.1: 6.0
  50 * Win10: 6.2
  51 */
  52
  53#define VMSTOR_PROTO_VERSION(MAJOR_, MINOR_)    ((((MAJOR_) & 0xff) << 8) | \
  54                                                (((MINOR_) & 0xff)))
  55
  56#define VMSTOR_PROTO_VERSION_WIN6       VMSTOR_PROTO_VERSION(2, 0)
  57#define VMSTOR_PROTO_VERSION_WIN7       VMSTOR_PROTO_VERSION(4, 2)
  58#define VMSTOR_PROTO_VERSION_WIN8       VMSTOR_PROTO_VERSION(5, 1)
  59#define VMSTOR_PROTO_VERSION_WIN8_1     VMSTOR_PROTO_VERSION(6, 0)
  60#define VMSTOR_PROTO_VERSION_WIN10      VMSTOR_PROTO_VERSION(6, 2)
  61
  62/*  Packet structure describing virtual storage requests. */
  63enum vstor_packet_operation {
  64        VSTOR_OPERATION_COMPLETE_IO             = 1,
  65        VSTOR_OPERATION_REMOVE_DEVICE           = 2,
  66        VSTOR_OPERATION_EXECUTE_SRB             = 3,
  67        VSTOR_OPERATION_RESET_LUN               = 4,
  68        VSTOR_OPERATION_RESET_ADAPTER           = 5,
  69        VSTOR_OPERATION_RESET_BUS               = 6,
  70        VSTOR_OPERATION_BEGIN_INITIALIZATION    = 7,
  71        VSTOR_OPERATION_END_INITIALIZATION      = 8,
  72        VSTOR_OPERATION_QUERY_PROTOCOL_VERSION  = 9,
  73        VSTOR_OPERATION_QUERY_PROPERTIES        = 10,
  74        VSTOR_OPERATION_ENUMERATE_BUS           = 11,
  75        VSTOR_OPERATION_FCHBA_DATA              = 12,
  76        VSTOR_OPERATION_CREATE_SUB_CHANNELS     = 13,
  77        VSTOR_OPERATION_MAXIMUM                 = 13
  78};
  79
  80/*
  81 * WWN packet for Fibre Channel HBA
  82 */
  83
  84struct hv_fc_wwn_packet {
  85        u8      primary_active;
  86        u8      reserved1[3];
  87        u8      primary_port_wwn[8];
  88        u8      primary_node_wwn[8];
  89        u8      secondary_port_wwn[8];
  90        u8      secondary_node_wwn[8];
  91};
  92
  93
  94
  95/*
  96 * SRB Flag Bits
  97 */
  98
  99#define SRB_FLAGS_QUEUE_ACTION_ENABLE           0x00000002
 100#define SRB_FLAGS_DISABLE_DISCONNECT            0x00000004
 101#define SRB_FLAGS_DISABLE_SYNCH_TRANSFER        0x00000008
 102#define SRB_FLAGS_BYPASS_FROZEN_QUEUE           0x00000010
 103#define SRB_FLAGS_DISABLE_AUTOSENSE             0x00000020
 104#define SRB_FLAGS_DATA_IN                       0x00000040
 105#define SRB_FLAGS_DATA_OUT                      0x00000080
 106#define SRB_FLAGS_NO_DATA_TRANSFER              0x00000000
 107#define SRB_FLAGS_UNSPECIFIED_DIRECTION (SRB_FLAGS_DATA_IN | SRB_FLAGS_DATA_OUT)
 108#define SRB_FLAGS_NO_QUEUE_FREEZE               0x00000100
 109#define SRB_FLAGS_ADAPTER_CACHE_ENABLE          0x00000200
 110#define SRB_FLAGS_FREE_SENSE_BUFFER             0x00000400
 111
 112/*
 113 * This flag indicates the request is part of the workflow for processing a D3.
 114 */
 115#define SRB_FLAGS_D3_PROCESSING                 0x00000800
 116#define SRB_FLAGS_IS_ACTIVE                     0x00010000
 117#define SRB_FLAGS_ALLOCATED_FROM_ZONE           0x00020000
 118#define SRB_FLAGS_SGLIST_FROM_POOL              0x00040000
 119#define SRB_FLAGS_BYPASS_LOCKED_QUEUE           0x00080000
 120#define SRB_FLAGS_NO_KEEP_AWAKE                 0x00100000
 121#define SRB_FLAGS_PORT_DRIVER_ALLOCSENSE        0x00200000
 122#define SRB_FLAGS_PORT_DRIVER_SENSEHASPORT      0x00400000
 123#define SRB_FLAGS_DONT_START_NEXT_PACKET        0x00800000
 124#define SRB_FLAGS_PORT_DRIVER_RESERVED          0x0F000000
 125#define SRB_FLAGS_CLASS_DRIVER_RESERVED         0xF0000000
 126
 127#define SP_UNTAGGED                     ((unsigned char) ~0)
 128#define SRB_SIMPLE_TAG_REQUEST          0x20
 129
 130/*
 131 * Platform neutral description of a scsi request -
 132 * this remains the same across the write regardless of 32/64 bit
 133 * note: it's patterned off the SCSI_PASS_THROUGH structure
 134 */
 135#define STORVSC_MAX_CMD_LEN                     0x10
 136
 137#define POST_WIN7_STORVSC_SENSE_BUFFER_SIZE     0x14
 138#define PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE      0x12
 139
 140#define STORVSC_SENSE_BUFFER_SIZE               0x14
 141#define STORVSC_MAX_BUF_LEN_WITH_PADDING        0x14
 142
 143/*
 144 * Sense buffer size changed in win8; have a run-time
 145 * variable to track the size we should use.  This value will
 146 * likely change during protocol negotiation but it is valid
 147 * to start by assuming pre-Win8.
 148 */
 149static int sense_buffer_size = PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE;
 150
 151/*
 152 * The storage protocol version is determined during the
 153 * initial exchange with the host.  It will indicate which
 154 * storage functionality is available in the host.
 155*/
 156static int vmstor_proto_version;
 157
 158#define STORVSC_LOGGING_NONE    0
 159#define STORVSC_LOGGING_ERROR   1
 160#define STORVSC_LOGGING_WARN    2
 161
 162static int logging_level = STORVSC_LOGGING_ERROR;
 163module_param(logging_level, int, S_IRUGO|S_IWUSR);
 164MODULE_PARM_DESC(logging_level,
 165        "Logging level, 0 - None, 1 - Error (default), 2 - Warning.");
 166
 167static inline bool do_logging(int level)
 168{
 169        return logging_level >= level;
 170}
 171
 172#define storvsc_log(dev, level, fmt, ...)                       \
 173do {                                                            \
 174        if (do_logging(level))                                  \
 175                dev_warn(&(dev)->device, fmt, ##__VA_ARGS__);   \
 176} while (0)
 177
 178struct vmscsi_win8_extension {
 179        /*
 180         * The following were added in Windows 8
 181         */
 182        u16 reserve;
 183        u8  queue_tag;
 184        u8  queue_action;
 185        u32 srb_flags;
 186        u32 time_out_value;
 187        u32 queue_sort_ey;
 188} __packed;
 189
 190struct vmscsi_request {
 191        u16 length;
 192        u8 srb_status;
 193        u8 scsi_status;
 194
 195        u8  port_number;
 196        u8  path_id;
 197        u8  target_id;
 198        u8  lun;
 199
 200        u8  cdb_length;
 201        u8  sense_info_length;
 202        u8  data_in;
 203        u8  reserved;
 204
 205        u32 data_transfer_length;
 206
 207        union {
 208                u8 cdb[STORVSC_MAX_CMD_LEN];
 209                u8 sense_data[STORVSC_SENSE_BUFFER_SIZE];
 210                u8 reserved_array[STORVSC_MAX_BUF_LEN_WITH_PADDING];
 211        };
 212        /*
 213         * The following was added in win8.
 214         */
 215        struct vmscsi_win8_extension win8_extension;
 216
 217} __attribute((packed));
 218
 219
 220/*
 221 * The size of the vmscsi_request has changed in win8. The
 222 * additional size is because of new elements added to the
 223 * structure. These elements are valid only when we are talking
 224 * to a win8 host.
 225 * Track the correction to size we need to apply. This value
 226 * will likely change during protocol negotiation but it is
 227 * valid to start by assuming pre-Win8.
 228 */
 229static int vmscsi_size_delta = sizeof(struct vmscsi_win8_extension);
 230
 231/*
 232 * The list of storage protocols in order of preference.
 233 */
 234struct vmstor_protocol {
 235        int protocol_version;
 236        int sense_buffer_size;
 237        int vmscsi_size_delta;
 238};
 239
 240
 241static const struct vmstor_protocol vmstor_protocols[] = {
 242        {
 243                VMSTOR_PROTO_VERSION_WIN10,
 244                POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
 245                0
 246        },
 247        {
 248                VMSTOR_PROTO_VERSION_WIN8_1,
 249                POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
 250                0
 251        },
 252        {
 253                VMSTOR_PROTO_VERSION_WIN8,
 254                POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
 255                0
 256        },
 257        {
 258                VMSTOR_PROTO_VERSION_WIN7,
 259                PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE,
 260                sizeof(struct vmscsi_win8_extension),
 261        },
 262        {
 263                VMSTOR_PROTO_VERSION_WIN6,
 264                PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE,
 265                sizeof(struct vmscsi_win8_extension),
 266        }
 267};
 268
 269
 270/*
 271 * This structure is sent during the initialization phase to get the different
 272 * properties of the channel.
 273 */
 274
 275#define STORAGE_CHANNEL_SUPPORTS_MULTI_CHANNEL          0x1
 276
 277struct vmstorage_channel_properties {
 278        u32 reserved;
 279        u16 max_channel_cnt;
 280        u16 reserved1;
 281
 282        u32 flags;
 283        u32   max_transfer_bytes;
 284
 285        u64  reserved2;
 286} __packed;
 287
 288/*  This structure is sent during the storage protocol negotiations. */
 289struct vmstorage_protocol_version {
 290        /* Major (MSW) and minor (LSW) version numbers. */
 291        u16 major_minor;
 292
 293        /*
 294         * Revision number is auto-incremented whenever this file is changed
 295         * (See FILL_VMSTOR_REVISION macro above).  Mismatch does not
 296         * definitely indicate incompatibility--but it does indicate mismatched
 297         * builds.
 298         * This is only used on the windows side. Just set it to 0.
 299         */
 300        u16 revision;
 301} __packed;
 302
 303/* Channel Property Flags */
 304#define STORAGE_CHANNEL_REMOVABLE_FLAG          0x1
 305#define STORAGE_CHANNEL_EMULATED_IDE_FLAG       0x2
 306
 307struct vstor_packet {
 308        /* Requested operation type */
 309        enum vstor_packet_operation operation;
 310
 311        /*  Flags - see below for values */
 312        u32 flags;
 313
 314        /* Status of the request returned from the server side. */
 315        u32 status;
 316
 317        /* Data payload area */
 318        union {
 319                /*
 320                 * Structure used to forward SCSI commands from the
 321                 * client to the server.
 322                 */
 323                struct vmscsi_request vm_srb;
 324
 325                /* Structure used to query channel properties. */
 326                struct vmstorage_channel_properties storage_channel_properties;
 327
 328                /* Used during version negotiations. */
 329                struct vmstorage_protocol_version version;
 330
 331                /* Fibre channel address packet */
 332                struct hv_fc_wwn_packet wwn_packet;
 333
 334                /* Number of sub-channels to create */
 335                u16 sub_channel_count;
 336
 337                /* This will be the maximum of the union members */
 338                u8  buffer[0x34];
 339        };
 340} __packed;
 341
 342/*
 343 * Packet Flags:
 344 *
 345 * This flag indicates that the server should send back a completion for this
 346 * packet.
 347 */
 348
 349#define REQUEST_COMPLETION_FLAG 0x1
 350
 351/* Matches Windows-end */
 352enum storvsc_request_type {
 353        WRITE_TYPE = 0,
 354        READ_TYPE,
 355        UNKNOWN_TYPE,
 356};
 357
 358/*
 359 * SRB status codes and masks; a subset of the codes used here.
 360 */
 361
 362#define SRB_STATUS_AUTOSENSE_VALID      0x80
 363#define SRB_STATUS_QUEUE_FROZEN         0x40
 364#define SRB_STATUS_INVALID_LUN  0x20
 365#define SRB_STATUS_SUCCESS      0x01
 366#define SRB_STATUS_ABORTED      0x02
 367#define SRB_STATUS_ERROR        0x04
 368#define SRB_STATUS_DATA_OVERRUN 0x12
 369
 370#define SRB_STATUS(status) \
 371        (status & ~(SRB_STATUS_AUTOSENSE_VALID | SRB_STATUS_QUEUE_FROZEN))
 372/*
 373 * This is the end of Protocol specific defines.
 374 */
 375
 376static int storvsc_ringbuffer_size = (128 * 1024);
 377static u32 max_outstanding_req_per_channel;
 378static int storvsc_change_queue_depth(struct scsi_device *sdev, int queue_depth);
 379
 380static int storvsc_vcpus_per_sub_channel = 4;
 381
 382module_param(storvsc_ringbuffer_size, int, S_IRUGO);
 383MODULE_PARM_DESC(storvsc_ringbuffer_size, "Ring buffer size (bytes)");
 384
 385module_param(storvsc_vcpus_per_sub_channel, int, S_IRUGO);
 386MODULE_PARM_DESC(storvsc_vcpus_per_sub_channel, "Ratio of VCPUs to subchannels");
 387
 388static int ring_avail_percent_lowater = 10;
 389module_param(ring_avail_percent_lowater, int, S_IRUGO);
 390MODULE_PARM_DESC(ring_avail_percent_lowater,
 391                "Select a channel if available ring size > this in percent");
 392
 393/*
 394 * Timeout in seconds for all devices managed by this driver.
 395 */
 396static int storvsc_timeout = 180;
 397
 398#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
 399static struct scsi_transport_template *fc_transport_template;
 400#endif
 401
 402static void storvsc_on_channel_callback(void *context);
 403
 404#define STORVSC_MAX_LUNS_PER_TARGET                     255
 405#define STORVSC_MAX_TARGETS                             2
 406#define STORVSC_MAX_CHANNELS                            8
 407
 408#define STORVSC_FC_MAX_LUNS_PER_TARGET                  255
 409#define STORVSC_FC_MAX_TARGETS                          128
 410#define STORVSC_FC_MAX_CHANNELS                         8
 411
 412#define STORVSC_IDE_MAX_LUNS_PER_TARGET                 64
 413#define STORVSC_IDE_MAX_TARGETS                         1
 414#define STORVSC_IDE_MAX_CHANNELS                        1
 415
 416struct storvsc_cmd_request {
 417        struct scsi_cmnd *cmd;
 418
 419        struct hv_device *device;
 420
 421        /* Synchronize the request/response if needed */
 422        struct completion wait_event;
 423
 424        struct vmbus_channel_packet_multipage_buffer mpb;
 425        struct vmbus_packet_mpb_array *payload;
 426        u32 payload_sz;
 427
 428        struct vstor_packet vstor_packet;
 429};
 430
 431
 432/* A storvsc device is a device object that contains a vmbus channel */
 433struct storvsc_device {
 434        struct hv_device *device;
 435
 436        bool     destroy;
 437        bool     drain_notify;
 438        atomic_t num_outstanding_req;
 439        struct Scsi_Host *host;
 440
 441        wait_queue_head_t waiting_to_drain;
 442
 443        /*
 444         * Each unique Port/Path/Target represents 1 channel ie scsi
 445         * controller. In reality, the pathid, targetid is always 0
 446         * and the port is set by us
 447         */
 448        unsigned int port_number;
 449        unsigned char path_id;
 450        unsigned char target_id;
 451
 452        /*
 453         * Max I/O, the device can support.
 454         */
 455        u32   max_transfer_bytes;
 456        /*
 457         * Number of sub-channels we will open.
 458         */
 459        u16 num_sc;
 460        struct vmbus_channel **stor_chns;
 461        /*
 462         * Mask of CPUs bound to subchannels.
 463         */
 464        struct cpumask alloced_cpus;
 465        /* Used for vsc/vsp channel reset process */
 466        struct storvsc_cmd_request init_request;
 467        struct storvsc_cmd_request reset_request;
 468        /*
 469         * Currently active port and node names for FC devices.
 470         */
 471        u64 node_name;
 472        u64 port_name;
 473#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
 474        struct fc_rport *rport;
 475#endif
 476};
 477
 478struct hv_host_device {
 479        struct hv_device *dev;
 480        unsigned int port;
 481        unsigned char path;
 482        unsigned char target;
 483        struct workqueue_struct *handle_error_wq;
 484        struct work_struct host_scan_work;
 485        struct Scsi_Host *host;
 486};
 487
 488struct storvsc_scan_work {
 489        struct work_struct work;
 490        struct Scsi_Host *host;
 491        u8 lun;
 492        u8 tgt_id;
 493};
 494
 495static void storvsc_device_scan(struct work_struct *work)
 496{
 497        struct storvsc_scan_work *wrk;
 498        struct scsi_device *sdev;
 499
 500        wrk = container_of(work, struct storvsc_scan_work, work);
 501
 502        sdev = scsi_device_lookup(wrk->host, 0, wrk->tgt_id, wrk->lun);
 503        if (!sdev)
 504                goto done;
 505        scsi_rescan_device(&sdev->sdev_gendev);
 506        scsi_device_put(sdev);
 507
 508done:
 509        kfree(wrk);
 510}
 511
 512static void storvsc_host_scan(struct work_struct *work)
 513{
 514        struct Scsi_Host *host;
 515        struct scsi_device *sdev;
 516        struct hv_host_device *host_device =
 517                container_of(work, struct hv_host_device, host_scan_work);
 518
 519        host = host_device->host;
 520        /*
 521         * Before scanning the host, first check to see if any of the
 522         * currrently known devices have been hot removed. We issue a
 523         * "unit ready" command against all currently known devices.
 524         * This I/O will result in an error for devices that have been
 525         * removed. As part of handling the I/O error, we remove the device.
 526         *
 527         * When a LUN is added or removed, the host sends us a signal to
 528         * scan the host. Thus we are forced to discover the LUNs that
 529         * may have been removed this way.
 530         */
 531        mutex_lock(&host->scan_mutex);
 532        shost_for_each_device(sdev, host)
 533                scsi_test_unit_ready(sdev, 1, 1, NULL);
 534        mutex_unlock(&host->scan_mutex);
 535        /*
 536         * Now scan the host to discover LUNs that may have been added.
 537         */
 538        scsi_scan_host(host);
 539}
 540
 541static void storvsc_remove_lun(struct work_struct *work)
 542{
 543        struct storvsc_scan_work *wrk;
 544        struct scsi_device *sdev;
 545
 546        wrk = container_of(work, struct storvsc_scan_work, work);
 547        if (!scsi_host_get(wrk->host))
 548                goto done;
 549
 550        sdev = scsi_device_lookup(wrk->host, 0, wrk->tgt_id, wrk->lun);
 551
 552        if (sdev) {
 553                scsi_remove_device(sdev);
 554                scsi_device_put(sdev);
 555        }
 556        scsi_host_put(wrk->host);
 557
 558done:
 559        kfree(wrk);
 560}
 561
 562
 563/*
 564 * We can get incoming messages from the host that are not in response to
 565 * messages that we have sent out. An example of this would be messages
 566 * received by the guest to notify dynamic addition/removal of LUNs. To
 567 * deal with potential race conditions where the driver may be in the
 568 * midst of being unloaded when we might receive an unsolicited message
 569 * from the host, we have implemented a mechanism to gurantee sequential
 570 * consistency:
 571 *
 572 * 1) Once the device is marked as being destroyed, we will fail all
 573 *    outgoing messages.
 574 * 2) We permit incoming messages when the device is being destroyed,
 575 *    only to properly account for messages already sent out.
 576 */
 577
 578static inline struct storvsc_device *get_out_stor_device(
 579                                        struct hv_device *device)
 580{
 581        struct storvsc_device *stor_device;
 582
 583        stor_device = hv_get_drvdata(device);
 584
 585        if (stor_device && stor_device->destroy)
 586                stor_device = NULL;
 587
 588        return stor_device;
 589}
 590
 591
 592static inline void storvsc_wait_to_drain(struct storvsc_device *dev)
 593{
 594        dev->drain_notify = true;
 595        wait_event(dev->waiting_to_drain,
 596                   atomic_read(&dev->num_outstanding_req) == 0);
 597        dev->drain_notify = false;
 598}
 599
 600static inline struct storvsc_device *get_in_stor_device(
 601                                        struct hv_device *device)
 602{
 603        struct storvsc_device *stor_device;
 604
 605        stor_device = hv_get_drvdata(device);
 606
 607        if (!stor_device)
 608                goto get_in_err;
 609
 610        /*
 611         * If the device is being destroyed; allow incoming
 612         * traffic only to cleanup outstanding requests.
 613         */
 614
 615        if (stor_device->destroy  &&
 616                (atomic_read(&stor_device->num_outstanding_req) == 0))
 617                stor_device = NULL;
 618
 619get_in_err:
 620        return stor_device;
 621
 622}
 623
 624static void handle_sc_creation(struct vmbus_channel *new_sc)
 625{
 626        struct hv_device *device = new_sc->primary_channel->device_obj;
 627        struct device *dev = &device->device;
 628        struct storvsc_device *stor_device;
 629        struct vmstorage_channel_properties props;
 630        int ret;
 631
 632        stor_device = get_out_stor_device(device);
 633        if (!stor_device)
 634                return;
 635
 636        memset(&props, 0, sizeof(struct vmstorage_channel_properties));
 637
 638        ret = vmbus_open(new_sc,
 639                         storvsc_ringbuffer_size,
 640                         storvsc_ringbuffer_size,
 641                         (void *)&props,
 642                         sizeof(struct vmstorage_channel_properties),
 643                         storvsc_on_channel_callback, new_sc);
 644
 645        /* In case vmbus_open() fails, we don't use the sub-channel. */
 646        if (ret != 0) {
 647                dev_err(dev, "Failed to open sub-channel: err=%d\n", ret);
 648                return;
 649        }
 650
 651        /* Add the sub-channel to the array of available channels. */
 652        stor_device->stor_chns[new_sc->target_cpu] = new_sc;
 653        cpumask_set_cpu(new_sc->target_cpu, &stor_device->alloced_cpus);
 654}
 655
 656static void  handle_multichannel_storage(struct hv_device *device, int max_chns)
 657{
 658        struct device *dev = &device->device;
 659        struct storvsc_device *stor_device;
 660        int num_sc;
 661        struct storvsc_cmd_request *request;
 662        struct vstor_packet *vstor_packet;
 663        int ret, t;
 664
 665        /*
 666         * If the number of CPUs is artificially restricted, such as
 667         * with maxcpus=1 on the kernel boot line, Hyper-V could offer
 668         * sub-channels >= the number of CPUs. These sub-channels
 669         * should not be created. The primary channel is already created
 670         * and assigned to one CPU, so check against # CPUs - 1.
 671         */
 672        num_sc = min((int)(num_online_cpus() - 1), max_chns);
 673        if (!num_sc)
 674                return;
 675
 676        stor_device = get_out_stor_device(device);
 677        if (!stor_device)
 678                return;
 679
 680        stor_device->num_sc = num_sc;
 681        request = &stor_device->init_request;
 682        vstor_packet = &request->vstor_packet;
 683
 684        /*
 685         * Establish a handler for dealing with subchannels.
 686         */
 687        vmbus_set_sc_create_callback(device->channel, handle_sc_creation);
 688
 689        /*
 690         * Request the host to create sub-channels.
 691         */
 692        memset(request, 0, sizeof(struct storvsc_cmd_request));
 693        init_completion(&request->wait_event);
 694        vstor_packet->operation = VSTOR_OPERATION_CREATE_SUB_CHANNELS;
 695        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 696        vstor_packet->sub_channel_count = num_sc;
 697
 698        ret = vmbus_sendpacket(device->channel, vstor_packet,
 699                               (sizeof(struct vstor_packet) -
 700                               vmscsi_size_delta),
 701                               (unsigned long)request,
 702                               VM_PKT_DATA_INBAND,
 703                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 704
 705        if (ret != 0) {
 706                dev_err(dev, "Failed to create sub-channel: err=%d\n", ret);
 707                return;
 708        }
 709
 710        t = wait_for_completion_timeout(&request->wait_event, 10*HZ);
 711        if (t == 0) {
 712                dev_err(dev, "Failed to create sub-channel: timed out\n");
 713                return;
 714        }
 715
 716        if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
 717            vstor_packet->status != 0) {
 718                dev_err(dev, "Failed to create sub-channel: op=%d, sts=%d\n",
 719                        vstor_packet->operation, vstor_packet->status);
 720                return;
 721        }
 722
 723        /*
 724         * We need to do nothing here, because vmbus_process_offer()
 725         * invokes channel->sc_creation_callback, which will open and use
 726         * the sub-channel(s).
 727         */
 728}
 729
 730static void cache_wwn(struct storvsc_device *stor_device,
 731                      struct vstor_packet *vstor_packet)
 732{
 733        /*
 734         * Cache the currently active port and node ww names.
 735         */
 736        if (vstor_packet->wwn_packet.primary_active) {
 737                stor_device->node_name =
 738                        wwn_to_u64(vstor_packet->wwn_packet.primary_node_wwn);
 739                stor_device->port_name =
 740                        wwn_to_u64(vstor_packet->wwn_packet.primary_port_wwn);
 741        } else {
 742                stor_device->node_name =
 743                        wwn_to_u64(vstor_packet->wwn_packet.secondary_node_wwn);
 744                stor_device->port_name =
 745                        wwn_to_u64(vstor_packet->wwn_packet.secondary_port_wwn);
 746        }
 747}
 748
 749
 750static int storvsc_execute_vstor_op(struct hv_device *device,
 751                                    struct storvsc_cmd_request *request,
 752                                    bool status_check)
 753{
 754        struct vstor_packet *vstor_packet;
 755        int ret, t;
 756
 757        vstor_packet = &request->vstor_packet;
 758
 759        init_completion(&request->wait_event);
 760        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 761
 762        ret = vmbus_sendpacket(device->channel, vstor_packet,
 763                               (sizeof(struct vstor_packet) -
 764                               vmscsi_size_delta),
 765                               (unsigned long)request,
 766                               VM_PKT_DATA_INBAND,
 767                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 768        if (ret != 0)
 769                return ret;
 770
 771        t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 772        if (t == 0)
 773                return -ETIMEDOUT;
 774
 775        if (!status_check)
 776                return ret;
 777
 778        if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
 779            vstor_packet->status != 0)
 780                return -EINVAL;
 781
 782        return ret;
 783}
 784
 785static int storvsc_channel_init(struct hv_device *device, bool is_fc)
 786{
 787        struct storvsc_device *stor_device;
 788        struct storvsc_cmd_request *request;
 789        struct vstor_packet *vstor_packet;
 790        int ret, i;
 791        int max_chns;
 792        bool process_sub_channels = false;
 793
 794        stor_device = get_out_stor_device(device);
 795        if (!stor_device)
 796                return -ENODEV;
 797
 798        request = &stor_device->init_request;
 799        vstor_packet = &request->vstor_packet;
 800
 801        /*
 802         * Now, initiate the vsc/vsp initialization protocol on the open
 803         * channel
 804         */
 805        memset(request, 0, sizeof(struct storvsc_cmd_request));
 806        vstor_packet->operation = VSTOR_OPERATION_BEGIN_INITIALIZATION;
 807        ret = storvsc_execute_vstor_op(device, request, true);
 808        if (ret)
 809                return ret;
 810        /*
 811         * Query host supported protocol version.
 812         */
 813
 814        for (i = 0; i < ARRAY_SIZE(vmstor_protocols); i++) {
 815                /* reuse the packet for version range supported */
 816                memset(vstor_packet, 0, sizeof(struct vstor_packet));
 817                vstor_packet->operation =
 818                        VSTOR_OPERATION_QUERY_PROTOCOL_VERSION;
 819
 820                vstor_packet->version.major_minor =
 821                        vmstor_protocols[i].protocol_version;
 822
 823                /*
 824                 * The revision number is only used in Windows; set it to 0.
 825                 */
 826                vstor_packet->version.revision = 0;
 827                ret = storvsc_execute_vstor_op(device, request, false);
 828                if (ret != 0)
 829                        return ret;
 830
 831                if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO)
 832                        return -EINVAL;
 833
 834                if (vstor_packet->status == 0) {
 835                        vmstor_proto_version =
 836                                vmstor_protocols[i].protocol_version;
 837
 838                        sense_buffer_size =
 839                                vmstor_protocols[i].sense_buffer_size;
 840
 841                        vmscsi_size_delta =
 842                                vmstor_protocols[i].vmscsi_size_delta;
 843
 844                        break;
 845                }
 846        }
 847
 848        if (vstor_packet->status != 0)
 849                return -EINVAL;
 850
 851
 852        memset(vstor_packet, 0, sizeof(struct vstor_packet));
 853        vstor_packet->operation = VSTOR_OPERATION_QUERY_PROPERTIES;
 854        ret = storvsc_execute_vstor_op(device, request, true);
 855        if (ret != 0)
 856                return ret;
 857
 858        /*
 859         * Check to see if multi-channel support is there.
 860         * Hosts that implement protocol version of 5.1 and above
 861         * support multi-channel.
 862         */
 863        max_chns = vstor_packet->storage_channel_properties.max_channel_cnt;
 864
 865        /*
 866         * Allocate state to manage the sub-channels.
 867         * We allocate an array based on the numbers of possible CPUs
 868         * (Hyper-V does not support cpu online/offline).
 869         * This Array will be sparseley populated with unique
 870         * channels - primary + sub-channels.
 871         * We will however populate all the slots to evenly distribute
 872         * the load.
 873         */
 874        stor_device->stor_chns = kcalloc(num_possible_cpus(), sizeof(void *),
 875                                         GFP_KERNEL);
 876        if (stor_device->stor_chns == NULL)
 877                return -ENOMEM;
 878
 879        stor_device->stor_chns[device->channel->target_cpu] = device->channel;
 880        cpumask_set_cpu(device->channel->target_cpu,
 881                        &stor_device->alloced_cpus);
 882
 883        if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN8) {
 884                if (vstor_packet->storage_channel_properties.flags &
 885                    STORAGE_CHANNEL_SUPPORTS_MULTI_CHANNEL)
 886                        process_sub_channels = true;
 887        }
 888        stor_device->max_transfer_bytes =
 889                vstor_packet->storage_channel_properties.max_transfer_bytes;
 890
 891        if (!is_fc)
 892                goto done;
 893
 894        /*
 895         * For FC devices retrieve FC HBA data.
 896         */
 897        memset(vstor_packet, 0, sizeof(struct vstor_packet));
 898        vstor_packet->operation = VSTOR_OPERATION_FCHBA_DATA;
 899        ret = storvsc_execute_vstor_op(device, request, true);
 900        if (ret != 0)
 901                return ret;
 902
 903        /*
 904         * Cache the currently active port and node ww names.
 905         */
 906        cache_wwn(stor_device, vstor_packet);
 907
 908done:
 909
 910        memset(vstor_packet, 0, sizeof(struct vstor_packet));
 911        vstor_packet->operation = VSTOR_OPERATION_END_INITIALIZATION;
 912        ret = storvsc_execute_vstor_op(device, request, true);
 913        if (ret != 0)
 914                return ret;
 915
 916        if (process_sub_channels)
 917                handle_multichannel_storage(device, max_chns);
 918
 919        return ret;
 920}
 921
 922static void storvsc_handle_error(struct vmscsi_request *vm_srb,
 923                                struct scsi_cmnd *scmnd,
 924                                struct Scsi_Host *host,
 925                                u8 asc, u8 ascq)
 926{
 927        struct storvsc_scan_work *wrk;
 928        void (*process_err_fn)(struct work_struct *work);
 929        struct hv_host_device *host_dev = shost_priv(host);
 930        bool do_work = false;
 931
 932        switch (SRB_STATUS(vm_srb->srb_status)) {
 933        case SRB_STATUS_ERROR:
 934                /*
 935                 * Let upper layer deal with error when
 936                 * sense message is present.
 937                 */
 938
 939                if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID)
 940                        break;
 941                /*
 942                 * If there is an error; offline the device since all
 943                 * error recovery strategies would have already been
 944                 * deployed on the host side. However, if the command
 945                 * were a pass-through command deal with it appropriately.
 946                 */
 947                switch (scmnd->cmnd[0]) {
 948                case ATA_16:
 949                case ATA_12:
 950                        set_host_byte(scmnd, DID_PASSTHROUGH);
 951                        break;
 952                /*
 953                 * On Some Windows hosts TEST_UNIT_READY command can return
 954                 * SRB_STATUS_ERROR, let the upper level code deal with it
 955                 * based on the sense information.
 956                 */
 957                case TEST_UNIT_READY:
 958                        break;
 959                default:
 960                        set_host_byte(scmnd, DID_ERROR);
 961                }
 962                break;
 963        case SRB_STATUS_INVALID_LUN:
 964                set_host_byte(scmnd, DID_NO_CONNECT);
 965                do_work = true;
 966                process_err_fn = storvsc_remove_lun;
 967                break;
 968        case SRB_STATUS_ABORTED:
 969                if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID &&
 970                    (asc == 0x2a) && (ascq == 0x9)) {
 971                        do_work = true;
 972                        process_err_fn = storvsc_device_scan;
 973                        /*
 974                         * Retry the I/O that trigerred this.
 975                         */
 976                        set_host_byte(scmnd, DID_REQUEUE);
 977                }
 978                break;
 979        }
 980
 981        if (!do_work)
 982                return;
 983
 984        /*
 985         * We need to schedule work to process this error; schedule it.
 986         */
 987        wrk = kmalloc(sizeof(struct storvsc_scan_work), GFP_ATOMIC);
 988        if (!wrk) {
 989                set_host_byte(scmnd, DID_TARGET_FAILURE);
 990                return;
 991        }
 992
 993        wrk->host = host;
 994        wrk->lun = vm_srb->lun;
 995        wrk->tgt_id = vm_srb->target_id;
 996        INIT_WORK(&wrk->work, process_err_fn);
 997        queue_work(host_dev->handle_error_wq, &wrk->work);
 998}
 999
1000
1001static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request,
1002                                       struct storvsc_device *stor_dev)
1003{
1004        struct scsi_cmnd *scmnd = cmd_request->cmd;
1005        struct scsi_sense_hdr sense_hdr;
1006        struct vmscsi_request *vm_srb;
1007        u32 data_transfer_length;
1008        struct Scsi_Host *host;
1009        u32 payload_sz = cmd_request->payload_sz;
1010        void *payload = cmd_request->payload;
1011
1012        host = stor_dev->host;
1013
1014        vm_srb = &cmd_request->vstor_packet.vm_srb;
1015        data_transfer_length = vm_srb->data_transfer_length;
1016
1017        scmnd->result = vm_srb->scsi_status;
1018
1019        if (scmnd->result) {
1020                if (scsi_normalize_sense(scmnd->sense_buffer,
1021                                SCSI_SENSE_BUFFERSIZE, &sense_hdr) &&
1022                    !(sense_hdr.sense_key == NOT_READY &&
1023                                 sense_hdr.asc == 0x03A) &&
1024                    do_logging(STORVSC_LOGGING_ERROR))
1025                        scsi_print_sense_hdr(scmnd->device, "storvsc",
1026                                             &sense_hdr);
1027        }
1028
1029        if (vm_srb->srb_status != SRB_STATUS_SUCCESS) {
1030                storvsc_handle_error(vm_srb, scmnd, host, sense_hdr.asc,
1031                                         sense_hdr.ascq);
1032                /*
1033                 * The Windows driver set data_transfer_length on
1034                 * SRB_STATUS_DATA_OVERRUN. On other errors, this value
1035                 * is untouched.  In these cases we set it to 0.
1036                 */
1037                if (vm_srb->srb_status != SRB_STATUS_DATA_OVERRUN)
1038                        data_transfer_length = 0;
1039        }
1040
1041        scsi_set_resid(scmnd,
1042                cmd_request->payload->range.len - data_transfer_length);
1043
1044        scmnd->scsi_done(scmnd);
1045
1046        if (payload_sz >
1047                sizeof(struct vmbus_channel_packet_multipage_buffer))
1048                kfree(payload);
1049}
1050
1051static void storvsc_on_io_completion(struct storvsc_device *stor_device,
1052                                  struct vstor_packet *vstor_packet,
1053                                  struct storvsc_cmd_request *request)
1054{
1055        struct vstor_packet *stor_pkt;
1056        struct hv_device *device = stor_device->device;
1057
1058        stor_pkt = &request->vstor_packet;
1059
1060        /*
1061         * The current SCSI handling on the host side does
1062         * not correctly handle:
1063         * INQUIRY command with page code parameter set to 0x80
1064         * MODE_SENSE command with cmd[2] == 0x1c
1065         *
1066         * Setup srb and scsi status so this won't be fatal.
1067         * We do this so we can distinguish truly fatal failues
1068         * (srb status == 0x4) and off-line the device in that case.
1069         */
1070
1071        if ((stor_pkt->vm_srb.cdb[0] == INQUIRY) ||
1072           (stor_pkt->vm_srb.cdb[0] == MODE_SENSE)) {
1073                vstor_packet->vm_srb.scsi_status = 0;
1074                vstor_packet->vm_srb.srb_status = SRB_STATUS_SUCCESS;
1075        }
1076
1077
1078        /* Copy over the status...etc */
1079        stor_pkt->vm_srb.scsi_status = vstor_packet->vm_srb.scsi_status;
1080        stor_pkt->vm_srb.srb_status = vstor_packet->vm_srb.srb_status;
1081        stor_pkt->vm_srb.sense_info_length =
1082        vstor_packet->vm_srb.sense_info_length;
1083
1084        if (vstor_packet->vm_srb.scsi_status != 0 ||
1085            vstor_packet->vm_srb.srb_status != SRB_STATUS_SUCCESS)
1086                storvsc_log(device, STORVSC_LOGGING_WARN,
1087                        "cmd 0x%x scsi status 0x%x srb status 0x%x\n",
1088                        stor_pkt->vm_srb.cdb[0],
1089                        vstor_packet->vm_srb.scsi_status,
1090                        vstor_packet->vm_srb.srb_status);
1091
1092        if ((vstor_packet->vm_srb.scsi_status & 0xFF) == 0x02) {
1093                /* CHECK_CONDITION */
1094                if (vstor_packet->vm_srb.srb_status &
1095                        SRB_STATUS_AUTOSENSE_VALID) {
1096                        /* autosense data available */
1097
1098                        storvsc_log(device, STORVSC_LOGGING_WARN,
1099                                "stor pkt %p autosense data valid - len %d\n",
1100                                request, vstor_packet->vm_srb.sense_info_length);
1101
1102                        memcpy(request->cmd->sense_buffer,
1103                               vstor_packet->vm_srb.sense_data,
1104                               vstor_packet->vm_srb.sense_info_length);
1105
1106                }
1107        }
1108
1109        stor_pkt->vm_srb.data_transfer_length =
1110        vstor_packet->vm_srb.data_transfer_length;
1111
1112        storvsc_command_completion(request, stor_device);
1113
1114        if (atomic_dec_and_test(&stor_device->num_outstanding_req) &&
1115                stor_device->drain_notify)
1116                wake_up(&stor_device->waiting_to_drain);
1117
1118
1119}
1120
1121static void storvsc_on_receive(struct storvsc_device *stor_device,
1122                             struct vstor_packet *vstor_packet,
1123                             struct storvsc_cmd_request *request)
1124{
1125        struct hv_host_device *host_dev;
1126        switch (vstor_packet->operation) {
1127        case VSTOR_OPERATION_COMPLETE_IO:
1128                storvsc_on_io_completion(stor_device, vstor_packet, request);
1129                break;
1130
1131        case VSTOR_OPERATION_REMOVE_DEVICE:
1132        case VSTOR_OPERATION_ENUMERATE_BUS:
1133                host_dev = shost_priv(stor_device->host);
1134                queue_work(
1135                        host_dev->handle_error_wq, &host_dev->host_scan_work);
1136                break;
1137
1138        case VSTOR_OPERATION_FCHBA_DATA:
1139                cache_wwn(stor_device, vstor_packet);
1140#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1141                fc_host_node_name(stor_device->host) = stor_device->node_name;
1142                fc_host_port_name(stor_device->host) = stor_device->port_name;
1143#endif
1144                break;
1145        default:
1146                break;
1147        }
1148}
1149
1150static void storvsc_on_channel_callback(void *context)
1151{
1152        struct vmbus_channel *channel = (struct vmbus_channel *)context;
1153        const struct vmpacket_descriptor *desc;
1154        struct hv_device *device;
1155        struct storvsc_device *stor_device;
1156
1157        if (channel->primary_channel != NULL)
1158                device = channel->primary_channel->device_obj;
1159        else
1160                device = channel->device_obj;
1161
1162        stor_device = get_in_stor_device(device);
1163        if (!stor_device)
1164                return;
1165
1166        foreach_vmbus_pkt(desc, channel) {
1167                void *packet = hv_pkt_data(desc);
1168                struct storvsc_cmd_request *request;
1169
1170                request = (struct storvsc_cmd_request *)
1171                        ((unsigned long)desc->trans_id);
1172
1173                if (request == &stor_device->init_request ||
1174                    request == &stor_device->reset_request) {
1175                        memcpy(&request->vstor_packet, packet,
1176                               (sizeof(struct vstor_packet) - vmscsi_size_delta));
1177                        complete(&request->wait_event);
1178                } else {
1179                        storvsc_on_receive(stor_device, packet, request);
1180                }
1181        }
1182}
1183
1184static int storvsc_connect_to_vsp(struct hv_device *device, u32 ring_size,
1185                                  bool is_fc)
1186{
1187        struct vmstorage_channel_properties props;
1188        int ret;
1189
1190        memset(&props, 0, sizeof(struct vmstorage_channel_properties));
1191
1192        ret = vmbus_open(device->channel,
1193                         ring_size,
1194                         ring_size,
1195                         (void *)&props,
1196                         sizeof(struct vmstorage_channel_properties),
1197                         storvsc_on_channel_callback, device->channel);
1198
1199        if (ret != 0)
1200                return ret;
1201
1202        ret = storvsc_channel_init(device, is_fc);
1203
1204        return ret;
1205}
1206
1207static int storvsc_dev_remove(struct hv_device *device)
1208{
1209        struct storvsc_device *stor_device;
1210
1211        stor_device = hv_get_drvdata(device);
1212
1213        stor_device->destroy = true;
1214
1215        /* Make sure flag is set before waiting */
1216        wmb();
1217
1218        /*
1219         * At this point, all outbound traffic should be disable. We
1220         * only allow inbound traffic (responses) to proceed so that
1221         * outstanding requests can be completed.
1222         */
1223
1224        storvsc_wait_to_drain(stor_device);
1225
1226        /*
1227         * Since we have already drained, we don't need to busy wait
1228         * as was done in final_release_stor_device()
1229         * Note that we cannot set the ext pointer to NULL until
1230         * we have drained - to drain the outgoing packets, we need to
1231         * allow incoming packets.
1232         */
1233        hv_set_drvdata(device, NULL);
1234
1235        /* Close the channel */
1236        vmbus_close(device->channel);
1237
1238        kfree(stor_device->stor_chns);
1239        kfree(stor_device);
1240        return 0;
1241}
1242
1243static struct vmbus_channel *get_og_chn(struct storvsc_device *stor_device,
1244                                        u16 q_num)
1245{
1246        u16 slot = 0;
1247        u16 hash_qnum;
1248        const struct cpumask *node_mask;
1249        int num_channels, tgt_cpu;
1250
1251        if (stor_device->num_sc == 0)
1252                return stor_device->device->channel;
1253
1254        /*
1255         * Our channel array is sparsley populated and we
1256         * initiated I/O on a processor/hw-q that does not
1257         * currently have a designated channel. Fix this.
1258         * The strategy is simple:
1259         * I. Ensure NUMA locality
1260         * II. Distribute evenly (best effort)
1261         * III. Mapping is persistent.
1262         */
1263
1264        node_mask = cpumask_of_node(cpu_to_node(q_num));
1265
1266        num_channels = 0;
1267        for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
1268                if (cpumask_test_cpu(tgt_cpu, node_mask))
1269                        num_channels++;
1270        }
1271        if (num_channels == 0)
1272                return stor_device->device->channel;
1273
1274        hash_qnum = q_num;
1275        while (hash_qnum >= num_channels)
1276                hash_qnum -= num_channels;
1277
1278        for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
1279                if (!cpumask_test_cpu(tgt_cpu, node_mask))
1280                        continue;
1281                if (slot == hash_qnum)
1282                        break;
1283                slot++;
1284        }
1285
1286        stor_device->stor_chns[q_num] = stor_device->stor_chns[tgt_cpu];
1287
1288        return stor_device->stor_chns[q_num];
1289}
1290
1291
1292static int storvsc_do_io(struct hv_device *device,
1293                         struct storvsc_cmd_request *request, u16 q_num)
1294{
1295        struct storvsc_device *stor_device;
1296        struct vstor_packet *vstor_packet;
1297        struct vmbus_channel *outgoing_channel, *channel;
1298        int ret = 0;
1299        const struct cpumask *node_mask;
1300        int tgt_cpu;
1301
1302        vstor_packet = &request->vstor_packet;
1303        stor_device = get_out_stor_device(device);
1304
1305        if (!stor_device)
1306                return -ENODEV;
1307
1308
1309        request->device  = device;
1310        /*
1311         * Select an an appropriate channel to send the request out.
1312         */
1313        if (stor_device->stor_chns[q_num] != NULL) {
1314                outgoing_channel = stor_device->stor_chns[q_num];
1315                if (outgoing_channel->target_cpu == q_num) {
1316                        /*
1317                         * Ideally, we want to pick a different channel if
1318                         * available on the same NUMA node.
1319                         */
1320                        node_mask = cpumask_of_node(cpu_to_node(q_num));
1321                        for_each_cpu_wrap(tgt_cpu,
1322                                 &stor_device->alloced_cpus, q_num + 1) {
1323                                if (!cpumask_test_cpu(tgt_cpu, node_mask))
1324                                        continue;
1325                                if (tgt_cpu == q_num)
1326                                        continue;
1327                                channel = stor_device->stor_chns[tgt_cpu];
1328                                if (hv_get_avail_to_write_percent(
1329                                                        &channel->outbound)
1330                                                > ring_avail_percent_lowater) {
1331                                        outgoing_channel = channel;
1332                                        goto found_channel;
1333                                }
1334                        }
1335
1336                        /*
1337                         * All the other channels on the same NUMA node are
1338                         * busy. Try to use the channel on the current CPU
1339                         */
1340                        if (hv_get_avail_to_write_percent(
1341                                                &outgoing_channel->outbound)
1342                                        > ring_avail_percent_lowater)
1343                                goto found_channel;
1344
1345                        /*
1346                         * If we reach here, all the channels on the current
1347                         * NUMA node are busy. Try to find a channel in
1348                         * other NUMA nodes
1349                         */
1350                        for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
1351                                if (cpumask_test_cpu(tgt_cpu, node_mask))
1352                                        continue;
1353                                channel = stor_device->stor_chns[tgt_cpu];
1354                                if (hv_get_avail_to_write_percent(
1355                                                        &channel->outbound)
1356                                                > ring_avail_percent_lowater) {
1357                                        outgoing_channel = channel;
1358                                        goto found_channel;
1359                                }
1360                        }
1361                }
1362        } else {
1363                outgoing_channel = get_og_chn(stor_device, q_num);
1364        }
1365
1366found_channel:
1367        vstor_packet->flags |= REQUEST_COMPLETION_FLAG;
1368
1369        vstor_packet->vm_srb.length = (sizeof(struct vmscsi_request) -
1370                                        vmscsi_size_delta);
1371
1372
1373        vstor_packet->vm_srb.sense_info_length = sense_buffer_size;
1374
1375
1376        vstor_packet->vm_srb.data_transfer_length =
1377        request->payload->range.len;
1378
1379        vstor_packet->operation = VSTOR_OPERATION_EXECUTE_SRB;
1380
1381        if (request->payload->range.len) {
1382
1383                ret = vmbus_sendpacket_mpb_desc(outgoing_channel,
1384                                request->payload, request->payload_sz,
1385                                vstor_packet,
1386                                (sizeof(struct vstor_packet) -
1387                                vmscsi_size_delta),
1388                                (unsigned long)request);
1389        } else {
1390                ret = vmbus_sendpacket(outgoing_channel, vstor_packet,
1391                               (sizeof(struct vstor_packet) -
1392                                vmscsi_size_delta),
1393                               (unsigned long)request,
1394                               VM_PKT_DATA_INBAND,
1395                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1396        }
1397
1398        if (ret != 0)
1399                return ret;
1400
1401        atomic_inc(&stor_device->num_outstanding_req);
1402
1403        return ret;
1404}
1405
1406static int storvsc_device_alloc(struct scsi_device *sdevice)
1407{
1408        /*
1409         * Set blist flag to permit the reading of the VPD pages even when
1410         * the target may claim SPC-2 compliance. MSFT targets currently
1411         * claim SPC-2 compliance while they implement post SPC-2 features.
1412         * With this flag we can correctly handle WRITE_SAME_16 issues.
1413         *
1414         * Hypervisor reports SCSI_UNKNOWN type for DVD ROM device but
1415         * still supports REPORT LUN.
1416         */
1417        sdevice->sdev_bflags = BLIST_REPORTLUN2 | BLIST_TRY_VPD_PAGES;
1418
1419        return 0;
1420}
1421
1422static int storvsc_device_configure(struct scsi_device *sdevice)
1423{
1424        blk_queue_rq_timeout(sdevice->request_queue, (storvsc_timeout * HZ));
1425
1426        /* Ensure there are no gaps in presented sgls */
1427        blk_queue_virt_boundary(sdevice->request_queue, PAGE_SIZE - 1);
1428
1429        sdevice->no_write_same = 1;
1430
1431        /*
1432         * If the host is WIN8 or WIN8 R2, claim conformance to SPC-3
1433         * if the device is a MSFT virtual device.  If the host is
1434         * WIN10 or newer, allow write_same.
1435         */
1436        if (!strncmp(sdevice->vendor, "Msft", 4)) {
1437                switch (vmstor_proto_version) {
1438                case VMSTOR_PROTO_VERSION_WIN8:
1439                case VMSTOR_PROTO_VERSION_WIN8_1:
1440                        sdevice->scsi_level = SCSI_SPC_3;
1441                        break;
1442                }
1443
1444                if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN10)
1445                        sdevice->no_write_same = 0;
1446        }
1447
1448        return 0;
1449}
1450
1451static int storvsc_get_chs(struct scsi_device *sdev, struct block_device * bdev,
1452                           sector_t capacity, int *info)
1453{
1454        sector_t nsect = capacity;
1455        sector_t cylinders = nsect;
1456        int heads, sectors_pt;
1457
1458        /*
1459         * We are making up these values; let us keep it simple.
1460         */
1461        heads = 0xff;
1462        sectors_pt = 0x3f;      /* Sectors per track */
1463        sector_div(cylinders, heads * sectors_pt);
1464        if ((sector_t)(cylinders + 1) * heads * sectors_pt < nsect)
1465                cylinders = 0xffff;
1466
1467        info[0] = heads;
1468        info[1] = sectors_pt;
1469        info[2] = (int)cylinders;
1470
1471        return 0;
1472}
1473
1474static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
1475{
1476        struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
1477        struct hv_device *device = host_dev->dev;
1478
1479        struct storvsc_device *stor_device;
1480        struct storvsc_cmd_request *request;
1481        struct vstor_packet *vstor_packet;
1482        int ret, t;
1483
1484
1485        stor_device = get_out_stor_device(device);
1486        if (!stor_device)
1487                return FAILED;
1488
1489        request = &stor_device->reset_request;
1490        vstor_packet = &request->vstor_packet;
1491
1492        init_completion(&request->wait_event);
1493
1494        vstor_packet->operation = VSTOR_OPERATION_RESET_BUS;
1495        vstor_packet->flags = REQUEST_COMPLETION_FLAG;
1496        vstor_packet->vm_srb.path_id = stor_device->path_id;
1497
1498        ret = vmbus_sendpacket(device->channel, vstor_packet,
1499                               (sizeof(struct vstor_packet) -
1500                                vmscsi_size_delta),
1501                               (unsigned long)&stor_device->reset_request,
1502                               VM_PKT_DATA_INBAND,
1503                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1504        if (ret != 0)
1505                return FAILED;
1506
1507        t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
1508        if (t == 0)
1509                return TIMEOUT_ERROR;
1510
1511
1512        /*
1513         * At this point, all outstanding requests in the adapter
1514         * should have been flushed out and return to us
1515         * There is a potential race here where the host may be in
1516         * the process of responding when we return from here.
1517         * Just wait for all in-transit packets to be accounted for
1518         * before we return from here.
1519         */
1520        storvsc_wait_to_drain(stor_device);
1521
1522        return SUCCESS;
1523}
1524
1525/*
1526 * The host guarantees to respond to each command, although I/O latencies might
1527 * be unbounded on Azure.  Reset the timer unconditionally to give the host a
1528 * chance to perform EH.
1529 */
1530static enum blk_eh_timer_return storvsc_eh_timed_out(struct scsi_cmnd *scmnd)
1531{
1532#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1533        if (scmnd->device->host->transportt == fc_transport_template)
1534                return fc_eh_timed_out(scmnd);
1535#endif
1536        return BLK_EH_RESET_TIMER;
1537}
1538
1539static bool storvsc_scsi_cmd_ok(struct scsi_cmnd *scmnd)
1540{
1541        bool allowed = true;
1542        u8 scsi_op = scmnd->cmnd[0];
1543
1544        switch (scsi_op) {
1545        /* the host does not handle WRITE_SAME, log accident usage */
1546        case WRITE_SAME:
1547        /*
1548         * smartd sends this command and the host does not handle
1549         * this. So, don't send it.
1550         */
1551        case SET_WINDOW:
1552                scmnd->result = ILLEGAL_REQUEST << 16;
1553                allowed = false;
1554                break;
1555        default:
1556                break;
1557        }
1558        return allowed;
1559}
1560
1561static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
1562{
1563        int ret;
1564        struct hv_host_device *host_dev = shost_priv(host);
1565        struct hv_device *dev = host_dev->dev;
1566        struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd);
1567        int i;
1568        struct scatterlist *sgl;
1569        unsigned int sg_count = 0;
1570        struct vmscsi_request *vm_srb;
1571        struct scatterlist *cur_sgl;
1572        struct vmbus_packet_mpb_array  *payload;
1573        u32 payload_sz;
1574        u32 length;
1575
1576        if (vmstor_proto_version <= VMSTOR_PROTO_VERSION_WIN8) {
1577                /*
1578                 * On legacy hosts filter unimplemented commands.
1579                 * Future hosts are expected to correctly handle
1580                 * unsupported commands. Furthermore, it is
1581                 * possible that some of the currently
1582                 * unsupported commands maybe supported in
1583                 * future versions of the host.
1584                 */
1585                if (!storvsc_scsi_cmd_ok(scmnd)) {
1586                        scmnd->scsi_done(scmnd);
1587                        return 0;
1588                }
1589        }
1590
1591        /* Setup the cmd request */
1592        cmd_request->cmd = scmnd;
1593
1594        vm_srb = &cmd_request->vstor_packet.vm_srb;
1595        vm_srb->win8_extension.time_out_value = 60;
1596
1597        vm_srb->win8_extension.srb_flags |=
1598                SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
1599
1600        if (scmnd->device->tagged_supported) {
1601                vm_srb->win8_extension.srb_flags |=
1602                (SRB_FLAGS_QUEUE_ACTION_ENABLE | SRB_FLAGS_NO_QUEUE_FREEZE);
1603                vm_srb->win8_extension.queue_tag = SP_UNTAGGED;
1604                vm_srb->win8_extension.queue_action = SRB_SIMPLE_TAG_REQUEST;
1605        }
1606
1607        /* Build the SRB */
1608        switch (scmnd->sc_data_direction) {
1609        case DMA_TO_DEVICE:
1610                vm_srb->data_in = WRITE_TYPE;
1611                vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_OUT;
1612                break;
1613        case DMA_FROM_DEVICE:
1614                vm_srb->data_in = READ_TYPE;
1615                vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_IN;
1616                break;
1617        case DMA_NONE:
1618                vm_srb->data_in = UNKNOWN_TYPE;
1619                vm_srb->win8_extension.srb_flags |= SRB_FLAGS_NO_DATA_TRANSFER;
1620                break;
1621        default:
1622                /*
1623                 * This is DMA_BIDIRECTIONAL or something else we are never
1624                 * supposed to see here.
1625                 */
1626                WARN(1, "Unexpected data direction: %d\n",
1627                     scmnd->sc_data_direction);
1628                return -EINVAL;
1629        }
1630
1631
1632        vm_srb->port_number = host_dev->port;
1633        vm_srb->path_id = scmnd->device->channel;
1634        vm_srb->target_id = scmnd->device->id;
1635        vm_srb->lun = scmnd->device->lun;
1636
1637        vm_srb->cdb_length = scmnd->cmd_len;
1638
1639        memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length);
1640
1641        sgl = (struct scatterlist *)scsi_sglist(scmnd);
1642        sg_count = scsi_sg_count(scmnd);
1643
1644        length = scsi_bufflen(scmnd);
1645        payload = (struct vmbus_packet_mpb_array *)&cmd_request->mpb;
1646        payload_sz = sizeof(cmd_request->mpb);
1647
1648        if (sg_count) {
1649                if (sg_count > MAX_PAGE_BUFFER_COUNT) {
1650
1651                        payload_sz = (sg_count * sizeof(u64) +
1652                                      sizeof(struct vmbus_packet_mpb_array));
1653                        payload = kzalloc(payload_sz, GFP_ATOMIC);
1654                        if (!payload)
1655                                return SCSI_MLQUEUE_DEVICE_BUSY;
1656                }
1657
1658                payload->range.len = length;
1659                payload->range.offset = sgl[0].offset;
1660
1661                cur_sgl = sgl;
1662                for (i = 0; i < sg_count; i++) {
1663                        payload->range.pfn_array[i] =
1664                                page_to_pfn(sg_page((cur_sgl)));
1665                        cur_sgl = sg_next(cur_sgl);
1666                }
1667        }
1668
1669        cmd_request->payload = payload;
1670        cmd_request->payload_sz = payload_sz;
1671
1672        /* Invokes the vsc to start an IO */
1673        ret = storvsc_do_io(dev, cmd_request, get_cpu());
1674        put_cpu();
1675
1676        if (ret == -EAGAIN) {
1677                if (payload_sz > sizeof(cmd_request->mpb))
1678                        kfree(payload);
1679                /* no more space */
1680                return SCSI_MLQUEUE_DEVICE_BUSY;
1681        }
1682
1683        return 0;
1684}
1685
1686static struct scsi_host_template scsi_driver = {
1687        .module =               THIS_MODULE,
1688        .name =                 "storvsc_host_t",
1689        .cmd_size =             sizeof(struct storvsc_cmd_request),
1690        .bios_param =           storvsc_get_chs,
1691        .queuecommand =         storvsc_queuecommand,
1692        .eh_host_reset_handler =        storvsc_host_reset_handler,
1693        .proc_name =            "storvsc_host",
1694        .eh_timed_out =         storvsc_eh_timed_out,
1695        .slave_alloc =          storvsc_device_alloc,
1696        .slave_configure =      storvsc_device_configure,
1697        .cmd_per_lun =          2048,
1698        .this_id =              -1,
1699        .use_clustering =       ENABLE_CLUSTERING,
1700        /* Make sure we dont get a sg segment crosses a page boundary */
1701        .dma_boundary =         PAGE_SIZE-1,
1702        .no_write_same =        1,
1703        .track_queue_depth =    1,
1704        .change_queue_depth =   storvsc_change_queue_depth,
1705};
1706
1707enum {
1708        SCSI_GUID,
1709        IDE_GUID,
1710        SFC_GUID,
1711};
1712
1713static const struct hv_vmbus_device_id id_table[] = {
1714        /* SCSI guid */
1715        { HV_SCSI_GUID,
1716          .driver_data = SCSI_GUID
1717        },
1718        /* IDE guid */
1719        { HV_IDE_GUID,
1720          .driver_data = IDE_GUID
1721        },
1722        /* Fibre Channel GUID */
1723        {
1724          HV_SYNTHFC_GUID,
1725          .driver_data = SFC_GUID
1726        },
1727        { },
1728};
1729
1730MODULE_DEVICE_TABLE(vmbus, id_table);
1731
1732static int storvsc_probe(struct hv_device *device,
1733                        const struct hv_vmbus_device_id *dev_id)
1734{
1735        int ret;
1736        int num_cpus = num_online_cpus();
1737        struct Scsi_Host *host;
1738        struct hv_host_device *host_dev;
1739        bool dev_is_ide = ((dev_id->driver_data == IDE_GUID) ? true : false);
1740        bool is_fc = ((dev_id->driver_data == SFC_GUID) ? true : false);
1741        int target = 0;
1742        struct storvsc_device *stor_device;
1743        int max_luns_per_target;
1744        int max_targets;
1745        int max_channels;
1746        int max_sub_channels = 0;
1747
1748        /*
1749         * Based on the windows host we are running on,
1750         * set state to properly communicate with the host.
1751         */
1752
1753        if (vmbus_proto_version < VERSION_WIN8) {
1754                max_luns_per_target = STORVSC_IDE_MAX_LUNS_PER_TARGET;
1755                max_targets = STORVSC_IDE_MAX_TARGETS;
1756                max_channels = STORVSC_IDE_MAX_CHANNELS;
1757        } else {
1758                max_luns_per_target = STORVSC_MAX_LUNS_PER_TARGET;
1759                max_targets = STORVSC_MAX_TARGETS;
1760                max_channels = STORVSC_MAX_CHANNELS;
1761                /*
1762                 * On Windows8 and above, we support sub-channels for storage
1763                 * on SCSI and FC controllers.
1764                 * The number of sub-channels offerred is based on the number of
1765                 * VCPUs in the guest.
1766                 */
1767                if (!dev_is_ide)
1768                        max_sub_channels =
1769                                (num_cpus - 1) / storvsc_vcpus_per_sub_channel;
1770        }
1771
1772        scsi_driver.can_queue = max_outstanding_req_per_channel *
1773                                (max_sub_channels + 1) *
1774                                (100 - ring_avail_percent_lowater) / 100;
1775
1776        host = scsi_host_alloc(&scsi_driver,
1777                               sizeof(struct hv_host_device));
1778        if (!host)
1779                return -ENOMEM;
1780
1781        host_dev = shost_priv(host);
1782        memset(host_dev, 0, sizeof(struct hv_host_device));
1783
1784        host_dev->port = host->host_no;
1785        host_dev->dev = device;
1786        host_dev->host = host;
1787
1788
1789        stor_device = kzalloc(sizeof(struct storvsc_device), GFP_KERNEL);
1790        if (!stor_device) {
1791                ret = -ENOMEM;
1792                goto err_out0;
1793        }
1794
1795        stor_device->destroy = false;
1796        init_waitqueue_head(&stor_device->waiting_to_drain);
1797        stor_device->device = device;
1798        stor_device->host = host;
1799        hv_set_drvdata(device, stor_device);
1800
1801        stor_device->port_number = host->host_no;
1802        ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size, is_fc);
1803        if (ret)
1804                goto err_out1;
1805
1806        host_dev->path = stor_device->path_id;
1807        host_dev->target = stor_device->target_id;
1808
1809        switch (dev_id->driver_data) {
1810        case SFC_GUID:
1811                host->max_lun = STORVSC_FC_MAX_LUNS_PER_TARGET;
1812                host->max_id = STORVSC_FC_MAX_TARGETS;
1813                host->max_channel = STORVSC_FC_MAX_CHANNELS - 1;
1814#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1815                host->transportt = fc_transport_template;
1816#endif
1817                break;
1818
1819        case SCSI_GUID:
1820                host->max_lun = max_luns_per_target;
1821                host->max_id = max_targets;
1822                host->max_channel = max_channels - 1;
1823                break;
1824
1825        default:
1826                host->max_lun = STORVSC_IDE_MAX_LUNS_PER_TARGET;
1827                host->max_id = STORVSC_IDE_MAX_TARGETS;
1828                host->max_channel = STORVSC_IDE_MAX_CHANNELS - 1;
1829                break;
1830        }
1831        /* max cmd length */
1832        host->max_cmd_len = STORVSC_MAX_CMD_LEN;
1833
1834        /*
1835         * set the table size based on the info we got
1836         * from the host.
1837         */
1838        host->sg_tablesize = (stor_device->max_transfer_bytes >> PAGE_SHIFT);
1839        /*
1840         * Set the number of HW queues we are supporting.
1841         */
1842        if (stor_device->num_sc != 0)
1843                host->nr_hw_queues = stor_device->num_sc + 1;
1844
1845        /*
1846         * Set the error handler work queue.
1847         */
1848        host_dev->handle_error_wq =
1849                        alloc_ordered_workqueue("storvsc_error_wq_%d",
1850                                                WQ_MEM_RECLAIM,
1851                                                host->host_no);
1852        if (!host_dev->handle_error_wq)
1853                goto err_out2;
1854        INIT_WORK(&host_dev->host_scan_work, storvsc_host_scan);
1855        /* Register the HBA and start the scsi bus scan */
1856        ret = scsi_add_host(host, &device->device);
1857        if (ret != 0)
1858                goto err_out3;
1859
1860        if (!dev_is_ide) {
1861                scsi_scan_host(host);
1862        } else {
1863                target = (device->dev_instance.b[5] << 8 |
1864                         device->dev_instance.b[4]);
1865                ret = scsi_add_device(host, 0, target, 0);
1866                if (ret)
1867                        goto err_out4;
1868        }
1869#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1870        if (host->transportt == fc_transport_template) {
1871                struct fc_rport_identifiers ids = {
1872                        .roles = FC_PORT_ROLE_FCP_DUMMY_INITIATOR,
1873                };
1874
1875                fc_host_node_name(host) = stor_device->node_name;
1876                fc_host_port_name(host) = stor_device->port_name;
1877                stor_device->rport = fc_remote_port_add(host, 0, &ids);
1878                if (!stor_device->rport) {
1879                        ret = -ENOMEM;
1880                        goto err_out4;
1881                }
1882        }
1883#endif
1884        return 0;
1885
1886err_out4:
1887        scsi_remove_host(host);
1888
1889err_out3:
1890        destroy_workqueue(host_dev->handle_error_wq);
1891
1892err_out2:
1893        /*
1894         * Once we have connected with the host, we would need to
1895         * to invoke storvsc_dev_remove() to rollback this state and
1896         * this call also frees up the stor_device; hence the jump around
1897         * err_out1 label.
1898         */
1899        storvsc_dev_remove(device);
1900        goto err_out0;
1901
1902err_out1:
1903        kfree(stor_device->stor_chns);
1904        kfree(stor_device);
1905
1906err_out0:
1907        scsi_host_put(host);
1908        return ret;
1909}
1910
1911/* Change a scsi target's queue depth */
1912static int storvsc_change_queue_depth(struct scsi_device *sdev, int queue_depth)
1913{
1914        if (queue_depth > scsi_driver.can_queue)
1915                queue_depth = scsi_driver.can_queue;
1916
1917        return scsi_change_queue_depth(sdev, queue_depth);
1918}
1919
1920static int storvsc_remove(struct hv_device *dev)
1921{
1922        struct storvsc_device *stor_device = hv_get_drvdata(dev);
1923        struct Scsi_Host *host = stor_device->host;
1924        struct hv_host_device *host_dev = shost_priv(host);
1925
1926#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1927        if (host->transportt == fc_transport_template) {
1928                fc_remote_port_delete(stor_device->rport);
1929                fc_remove_host(host);
1930        }
1931#endif
1932        destroy_workqueue(host_dev->handle_error_wq);
1933        scsi_remove_host(host);
1934        storvsc_dev_remove(dev);
1935        scsi_host_put(host);
1936
1937        return 0;
1938}
1939
1940static struct hv_driver storvsc_drv = {
1941        .name = KBUILD_MODNAME,
1942        .id_table = id_table,
1943        .probe = storvsc_probe,
1944        .remove = storvsc_remove,
1945        .driver = {
1946                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1947        },
1948};
1949
1950#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1951static struct fc_function_template fc_transport_functions = {
1952        .show_host_node_name = 1,
1953        .show_host_port_name = 1,
1954};
1955#endif
1956
1957static int __init storvsc_drv_init(void)
1958{
1959        int ret;
1960
1961        /*
1962         * Divide the ring buffer data size (which is 1 page less
1963         * than the ring buffer size since that page is reserved for
1964         * the ring buffer indices) by the max request size (which is
1965         * vmbus_channel_packet_multipage_buffer + struct vstor_packet + u64)
1966         */
1967        max_outstanding_req_per_channel =
1968                ((storvsc_ringbuffer_size - PAGE_SIZE) /
1969                ALIGN(MAX_MULTIPAGE_BUFFER_PACKET +
1970                sizeof(struct vstor_packet) + sizeof(u64) -
1971                vmscsi_size_delta,
1972                sizeof(u64)));
1973
1974#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1975        fc_transport_template = fc_attach_transport(&fc_transport_functions);
1976        if (!fc_transport_template)
1977                return -ENODEV;
1978#endif
1979
1980        ret = vmbus_driver_register(&storvsc_drv);
1981
1982#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1983        if (ret)
1984                fc_release_transport(fc_transport_template);
1985#endif
1986
1987        return ret;
1988}
1989
1990static void __exit storvsc_drv_exit(void)
1991{
1992        vmbus_driver_unregister(&storvsc_drv);
1993#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1994        fc_release_transport(fc_transport_template);
1995#endif
1996}
1997
1998MODULE_LICENSE("GPL");
1999MODULE_DESCRIPTION("Microsoft Hyper-V virtual storage driver");
2000module_init(storvsc_drv_init);
2001module_exit(storvsc_drv_exit);
2002