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