whiterose

linux unikernel
Log | Files | Refs | README | LICENSE | git clone https://git.ne02ptzero.me/git/whiterose

storvsc_drv.c (52546B)


      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. */
     75 enum 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 
     96 struct 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  */
    161 static 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 */
    168 static int vmstor_proto_version;
    169 
    170 #define STORVSC_LOGGING_NONE	0
    171 #define STORVSC_LOGGING_ERROR	1
    172 #define STORVSC_LOGGING_WARN	2
    173 
    174 static int logging_level = STORVSC_LOGGING_ERROR;
    175 module_param(logging_level, int, S_IRUGO|S_IWUSR);
    176 MODULE_PARM_DESC(logging_level,
    177 	"Logging level, 0 - None, 1 - Error (default), 2 - Warning.");
    178 
    179 static inline bool do_logging(int level)
    180 {
    181 	return logging_level >= level;
    182 }
    183 
    184 #define storvsc_log(dev, level, fmt, ...)			\
    185 do {								\
    186 	if (do_logging(level))					\
    187 		dev_warn(&(dev)->device, fmt, ##__VA_ARGS__);	\
    188 } while (0)
    189 
    190 struct 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 
    202 struct 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  */
    241 static int vmscsi_size_delta = sizeof(struct vmscsi_win8_extension);
    242 
    243 /*
    244  * The list of storage protocols in order of preference.
    245  */
    246 struct vmstor_protocol {
    247 	int protocol_version;
    248 	int sense_buffer_size;
    249 	int vmscsi_size_delta;
    250 };
    251 
    252 
    253 static 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 
    289 struct 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. */
    301 struct 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 
    319 struct 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 */
    364 enum 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 
    388 static int storvsc_ringbuffer_size = (128 * 1024);
    389 static u32 max_outstanding_req_per_channel;
    390 
    391 static int storvsc_vcpus_per_sub_channel = 4;
    392 
    393 module_param(storvsc_ringbuffer_size, int, S_IRUGO);
    394 MODULE_PARM_DESC(storvsc_ringbuffer_size, "Ring buffer size (bytes)");
    395 
    396 module_param(storvsc_vcpus_per_sub_channel, int, S_IRUGO);
    397 MODULE_PARM_DESC(storvsc_vcpus_per_sub_channel, "Ratio of VCPUs to subchannels");
    398 
    399 static int ring_avail_percent_lowater = 10;
    400 module_param(ring_avail_percent_lowater, int, S_IRUGO);
    401 MODULE_PARM_DESC(ring_avail_percent_lowater,
    402 		"Select a channel if available ring size > this in percent");
    403 
    404 /*
    405  * Timeout in seconds for all devices managed by this driver.
    406  */
    407 static int storvsc_timeout = 180;
    408 
    409 #if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
    410 static struct scsi_transport_template *fc_transport_template;
    411 #endif
    412 
    413 static void storvsc_on_channel_callback(void *context);
    414 
    415 #define STORVSC_MAX_LUNS_PER_TARGET			255
    416 #define STORVSC_MAX_TARGETS				2
    417 #define STORVSC_MAX_CHANNELS				8
    418 
    419 #define STORVSC_FC_MAX_LUNS_PER_TARGET			255
    420 #define STORVSC_FC_MAX_TARGETS				128
    421 #define STORVSC_FC_MAX_CHANNELS				8
    422 
    423 #define STORVSC_IDE_MAX_LUNS_PER_TARGET			64
    424 #define STORVSC_IDE_MAX_TARGETS				1
    425 #define STORVSC_IDE_MAX_CHANNELS			1
    426 
    427 struct storvsc_cmd_request {
    428 	struct scsi_cmnd *cmd;
    429 
    430 	struct hv_device *device;
    431 
    432 	/* Synchronize the request/response if needed */
    433 	struct completion wait_event;
    434 
    435 	struct vmbus_channel_packet_multipage_buffer mpb;
    436 	struct vmbus_packet_mpb_array *payload;
    437 	u32 payload_sz;
    438 
    439 	struct vstor_packet vstor_packet;
    440 };
    441 
    442 
    443 /* A storvsc device is a device object that contains a vmbus channel */
    444 struct storvsc_device {
    445 	struct hv_device *device;
    446 
    447 	bool	 destroy;
    448 	bool	 drain_notify;
    449 	atomic_t num_outstanding_req;
    450 	struct Scsi_Host *host;
    451 
    452 	wait_queue_head_t waiting_to_drain;
    453 
    454 	/*
    455 	 * Each unique Port/Path/Target represents 1 channel ie scsi
    456 	 * controller. In reality, the pathid, targetid is always 0
    457 	 * and the port is set by us
    458 	 */
    459 	unsigned int port_number;
    460 	unsigned char path_id;
    461 	unsigned char target_id;
    462 
    463 	/*
    464 	 * Max I/O, the device can support.
    465 	 */
    466 	u32   max_transfer_bytes;
    467 	/*
    468 	 * Number of sub-channels we will open.
    469 	 */
    470 	u16 num_sc;
    471 	struct vmbus_channel **stor_chns;
    472 	/*
    473 	 * Mask of CPUs bound to subchannels.
    474 	 */
    475 	struct cpumask alloced_cpus;
    476 	/* Used for vsc/vsp channel reset process */
    477 	struct storvsc_cmd_request init_request;
    478 	struct storvsc_cmd_request reset_request;
    479 	/*
    480 	 * Currently active port and node names for FC devices.
    481 	 */
    482 	u64 node_name;
    483 	u64 port_name;
    484 #if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
    485 	struct fc_rport *rport;
    486 #endif
    487 };
    488 
    489 struct hv_host_device {
    490 	struct hv_device *dev;
    491 	unsigned int port;
    492 	unsigned char path;
    493 	unsigned char target;
    494 	struct workqueue_struct *handle_error_wq;
    495 	struct work_struct host_scan_work;
    496 	struct Scsi_Host *host;
    497 };
    498 
    499 struct storvsc_scan_work {
    500 	struct work_struct work;
    501 	struct Scsi_Host *host;
    502 	u8 lun;
    503 	u8 tgt_id;
    504 };
    505 
    506 static void storvsc_device_scan(struct work_struct *work)
    507 {
    508 	struct storvsc_scan_work *wrk;
    509 	struct scsi_device *sdev;
    510 
    511 	wrk = container_of(work, struct storvsc_scan_work, work);
    512 
    513 	sdev = scsi_device_lookup(wrk->host, 0, wrk->tgt_id, wrk->lun);
    514 	if (!sdev)
    515 		goto done;
    516 	scsi_rescan_device(&sdev->sdev_gendev);
    517 	scsi_device_put(sdev);
    518 
    519 done:
    520 	kfree(wrk);
    521 }
    522 
    523 static void storvsc_host_scan(struct work_struct *work)
    524 {
    525 	struct Scsi_Host *host;
    526 	struct scsi_device *sdev;
    527 	struct hv_host_device *host_device =
    528 		container_of(work, struct hv_host_device, host_scan_work);
    529 
    530 	host = host_device->host;
    531 	/*
    532 	 * Before scanning the host, first check to see if any of the
    533 	 * currrently known devices have been hot removed. We issue a
    534 	 * "unit ready" command against all currently known devices.
    535 	 * This I/O will result in an error for devices that have been
    536 	 * removed. As part of handling the I/O error, we remove the device.
    537 	 *
    538 	 * When a LUN is added or removed, the host sends us a signal to
    539 	 * scan the host. Thus we are forced to discover the LUNs that
    540 	 * may have been removed this way.
    541 	 */
    542 	mutex_lock(&host->scan_mutex);
    543 	shost_for_each_device(sdev, host)
    544 		scsi_test_unit_ready(sdev, 1, 1, NULL);
    545 	mutex_unlock(&host->scan_mutex);
    546 	/*
    547 	 * Now scan the host to discover LUNs that may have been added.
    548 	 */
    549 	scsi_scan_host(host);
    550 }
    551 
    552 static void storvsc_remove_lun(struct work_struct *work)
    553 {
    554 	struct storvsc_scan_work *wrk;
    555 	struct scsi_device *sdev;
    556 
    557 	wrk = container_of(work, struct storvsc_scan_work, work);
    558 	if (!scsi_host_get(wrk->host))
    559 		goto done;
    560 
    561 	sdev = scsi_device_lookup(wrk->host, 0, wrk->tgt_id, wrk->lun);
    562 
    563 	if (sdev) {
    564 		scsi_remove_device(sdev);
    565 		scsi_device_put(sdev);
    566 	}
    567 	scsi_host_put(wrk->host);
    568 
    569 done:
    570 	kfree(wrk);
    571 }
    572 
    573 
    574 /*
    575  * We can get incoming messages from the host that are not in response to
    576  * messages that we have sent out. An example of this would be messages
    577  * received by the guest to notify dynamic addition/removal of LUNs. To
    578  * deal with potential race conditions where the driver may be in the
    579  * midst of being unloaded when we might receive an unsolicited message
    580  * from the host, we have implemented a mechanism to gurantee sequential
    581  * consistency:
    582  *
    583  * 1) Once the device is marked as being destroyed, we will fail all
    584  *    outgoing messages.
    585  * 2) We permit incoming messages when the device is being destroyed,
    586  *    only to properly account for messages already sent out.
    587  */
    588 
    589 static inline struct storvsc_device *get_out_stor_device(
    590 					struct hv_device *device)
    591 {
    592 	struct storvsc_device *stor_device;
    593 
    594 	stor_device = hv_get_drvdata(device);
    595 
    596 	if (stor_device && stor_device->destroy)
    597 		stor_device = NULL;
    598 
    599 	return stor_device;
    600 }
    601 
    602 
    603 static inline void storvsc_wait_to_drain(struct storvsc_device *dev)
    604 {
    605 	dev->drain_notify = true;
    606 	wait_event(dev->waiting_to_drain,
    607 		   atomic_read(&dev->num_outstanding_req) == 0);
    608 	dev->drain_notify = false;
    609 }
    610 
    611 static inline struct storvsc_device *get_in_stor_device(
    612 					struct hv_device *device)
    613 {
    614 	struct storvsc_device *stor_device;
    615 
    616 	stor_device = hv_get_drvdata(device);
    617 
    618 	if (!stor_device)
    619 		goto get_in_err;
    620 
    621 	/*
    622 	 * If the device is being destroyed; allow incoming
    623 	 * traffic only to cleanup outstanding requests.
    624 	 */
    625 
    626 	if (stor_device->destroy  &&
    627 		(atomic_read(&stor_device->num_outstanding_req) == 0))
    628 		stor_device = NULL;
    629 
    630 get_in_err:
    631 	return stor_device;
    632 
    633 }
    634 
    635 static void handle_sc_creation(struct vmbus_channel *new_sc)
    636 {
    637 	struct hv_device *device = new_sc->primary_channel->device_obj;
    638 	struct device *dev = &device->device;
    639 	struct storvsc_device *stor_device;
    640 	struct vmstorage_channel_properties props;
    641 	int ret;
    642 
    643 	stor_device = get_out_stor_device(device);
    644 	if (!stor_device)
    645 		return;
    646 
    647 	memset(&props, 0, sizeof(struct vmstorage_channel_properties));
    648 
    649 	ret = vmbus_open(new_sc,
    650 			 storvsc_ringbuffer_size,
    651 			 storvsc_ringbuffer_size,
    652 			 (void *)&props,
    653 			 sizeof(struct vmstorage_channel_properties),
    654 			 storvsc_on_channel_callback, new_sc);
    655 
    656 	/* In case vmbus_open() fails, we don't use the sub-channel. */
    657 	if (ret != 0) {
    658 		dev_err(dev, "Failed to open sub-channel: err=%d\n", ret);
    659 		return;
    660 	}
    661 
    662 	/* Add the sub-channel to the array of available channels. */
    663 	stor_device->stor_chns[new_sc->target_cpu] = new_sc;
    664 	cpumask_set_cpu(new_sc->target_cpu, &stor_device->alloced_cpus);
    665 }
    666 
    667 static void  handle_multichannel_storage(struct hv_device *device, int max_chns)
    668 {
    669 	struct device *dev = &device->device;
    670 	struct storvsc_device *stor_device;
    671 	int num_sc;
    672 	struct storvsc_cmd_request *request;
    673 	struct vstor_packet *vstor_packet;
    674 	int ret, t;
    675 
    676 	/*
    677 	 * If the number of CPUs is artificially restricted, such as
    678 	 * with maxcpus=1 on the kernel boot line, Hyper-V could offer
    679 	 * sub-channels >= the number of CPUs. These sub-channels
    680 	 * should not be created. The primary channel is already created
    681 	 * and assigned to one CPU, so check against # CPUs - 1.
    682 	 */
    683 	num_sc = min((int)(num_online_cpus() - 1), max_chns);
    684 	if (!num_sc)
    685 		return;
    686 
    687 	stor_device = get_out_stor_device(device);
    688 	if (!stor_device)
    689 		return;
    690 
    691 	stor_device->num_sc = num_sc;
    692 	request = &stor_device->init_request;
    693 	vstor_packet = &request->vstor_packet;
    694 
    695 	/*
    696 	 * Establish a handler for dealing with subchannels.
    697 	 */
    698 	vmbus_set_sc_create_callback(device->channel, handle_sc_creation);
    699 
    700 	/*
    701 	 * Request the host to create sub-channels.
    702 	 */
    703 	memset(request, 0, sizeof(struct storvsc_cmd_request));
    704 	init_completion(&request->wait_event);
    705 	vstor_packet->operation = VSTOR_OPERATION_CREATE_SUB_CHANNELS;
    706 	vstor_packet->flags = REQUEST_COMPLETION_FLAG;
    707 	vstor_packet->sub_channel_count = num_sc;
    708 
    709 	ret = vmbus_sendpacket(device->channel, vstor_packet,
    710 			       (sizeof(struct vstor_packet) -
    711 			       vmscsi_size_delta),
    712 			       (unsigned long)request,
    713 			       VM_PKT_DATA_INBAND,
    714 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
    715 
    716 	if (ret != 0) {
    717 		dev_err(dev, "Failed to create sub-channel: err=%d\n", ret);
    718 		return;
    719 	}
    720 
    721 	t = wait_for_completion_timeout(&request->wait_event, 10*HZ);
    722 	if (t == 0) {
    723 		dev_err(dev, "Failed to create sub-channel: timed out\n");
    724 		return;
    725 	}
    726 
    727 	if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
    728 	    vstor_packet->status != 0) {
    729 		dev_err(dev, "Failed to create sub-channel: op=%d, sts=%d\n",
    730 			vstor_packet->operation, vstor_packet->status);
    731 		return;
    732 	}
    733 
    734 	/*
    735 	 * We need to do nothing here, because vmbus_process_offer()
    736 	 * invokes channel->sc_creation_callback, which will open and use
    737 	 * the sub-channel(s).
    738 	 */
    739 }
    740 
    741 static void cache_wwn(struct storvsc_device *stor_device,
    742 		      struct vstor_packet *vstor_packet)
    743 {
    744 	/*
    745 	 * Cache the currently active port and node ww names.
    746 	 */
    747 	if (vstor_packet->wwn_packet.primary_active) {
    748 		stor_device->node_name =
    749 			wwn_to_u64(vstor_packet->wwn_packet.primary_node_wwn);
    750 		stor_device->port_name =
    751 			wwn_to_u64(vstor_packet->wwn_packet.primary_port_wwn);
    752 	} else {
    753 		stor_device->node_name =
    754 			wwn_to_u64(vstor_packet->wwn_packet.secondary_node_wwn);
    755 		stor_device->port_name =
    756 			wwn_to_u64(vstor_packet->wwn_packet.secondary_port_wwn);
    757 	}
    758 }
    759 
    760 
    761 static int storvsc_execute_vstor_op(struct hv_device *device,
    762 				    struct storvsc_cmd_request *request,
    763 				    bool status_check)
    764 {
    765 	struct vstor_packet *vstor_packet;
    766 	int ret, t;
    767 
    768 	vstor_packet = &request->vstor_packet;
    769 
    770 	init_completion(&request->wait_event);
    771 	vstor_packet->flags = REQUEST_COMPLETION_FLAG;
    772 
    773 	ret = vmbus_sendpacket(device->channel, vstor_packet,
    774 			       (sizeof(struct vstor_packet) -
    775 			       vmscsi_size_delta),
    776 			       (unsigned long)request,
    777 			       VM_PKT_DATA_INBAND,
    778 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
    779 	if (ret != 0)
    780 		return ret;
    781 
    782 	t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
    783 	if (t == 0)
    784 		return -ETIMEDOUT;
    785 
    786 	if (!status_check)
    787 		return ret;
    788 
    789 	if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
    790 	    vstor_packet->status != 0)
    791 		return -EINVAL;
    792 
    793 	return ret;
    794 }
    795 
    796 static int storvsc_channel_init(struct hv_device *device, bool is_fc)
    797 {
    798 	struct storvsc_device *stor_device;
    799 	struct storvsc_cmd_request *request;
    800 	struct vstor_packet *vstor_packet;
    801 	int ret, i;
    802 	int max_chns;
    803 	bool process_sub_channels = false;
    804 
    805 	stor_device = get_out_stor_device(device);
    806 	if (!stor_device)
    807 		return -ENODEV;
    808 
    809 	request = &stor_device->init_request;
    810 	vstor_packet = &request->vstor_packet;
    811 
    812 	/*
    813 	 * Now, initiate the vsc/vsp initialization protocol on the open
    814 	 * channel
    815 	 */
    816 	memset(request, 0, sizeof(struct storvsc_cmd_request));
    817 	vstor_packet->operation = VSTOR_OPERATION_BEGIN_INITIALIZATION;
    818 	ret = storvsc_execute_vstor_op(device, request, true);
    819 	if (ret)
    820 		return ret;
    821 	/*
    822 	 * Query host supported protocol version.
    823 	 */
    824 
    825 	for (i = 0; i < ARRAY_SIZE(vmstor_protocols); i++) {
    826 		/* reuse the packet for version range supported */
    827 		memset(vstor_packet, 0, sizeof(struct vstor_packet));
    828 		vstor_packet->operation =
    829 			VSTOR_OPERATION_QUERY_PROTOCOL_VERSION;
    830 
    831 		vstor_packet->version.major_minor =
    832 			vmstor_protocols[i].protocol_version;
    833 
    834 		/*
    835 		 * The revision number is only used in Windows; set it to 0.
    836 		 */
    837 		vstor_packet->version.revision = 0;
    838 		ret = storvsc_execute_vstor_op(device, request, false);
    839 		if (ret != 0)
    840 			return ret;
    841 
    842 		if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO)
    843 			return -EINVAL;
    844 
    845 		if (vstor_packet->status == 0) {
    846 			vmstor_proto_version =
    847 				vmstor_protocols[i].protocol_version;
    848 
    849 			sense_buffer_size =
    850 				vmstor_protocols[i].sense_buffer_size;
    851 
    852 			vmscsi_size_delta =
    853 				vmstor_protocols[i].vmscsi_size_delta;
    854 
    855 			break;
    856 		}
    857 	}
    858 
    859 	if (vstor_packet->status != 0)
    860 		return -EINVAL;
    861 
    862 
    863 	memset(vstor_packet, 0, sizeof(struct vstor_packet));
    864 	vstor_packet->operation = VSTOR_OPERATION_QUERY_PROPERTIES;
    865 	ret = storvsc_execute_vstor_op(device, request, true);
    866 	if (ret != 0)
    867 		return ret;
    868 
    869 	/*
    870 	 * Check to see if multi-channel support is there.
    871 	 * Hosts that implement protocol version of 5.1 and above
    872 	 * support multi-channel.
    873 	 */
    874 	max_chns = vstor_packet->storage_channel_properties.max_channel_cnt;
    875 
    876 	/*
    877 	 * Allocate state to manage the sub-channels.
    878 	 * We allocate an array based on the numbers of possible CPUs
    879 	 * (Hyper-V does not support cpu online/offline).
    880 	 * This Array will be sparseley populated with unique
    881 	 * channels - primary + sub-channels.
    882 	 * We will however populate all the slots to evenly distribute
    883 	 * the load.
    884 	 */
    885 	stor_device->stor_chns = kcalloc(num_possible_cpus(), sizeof(void *),
    886 					 GFP_KERNEL);
    887 	if (stor_device->stor_chns == NULL)
    888 		return -ENOMEM;
    889 
    890 	stor_device->stor_chns[device->channel->target_cpu] = device->channel;
    891 	cpumask_set_cpu(device->channel->target_cpu,
    892 			&stor_device->alloced_cpus);
    893 
    894 	if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN8) {
    895 		if (vstor_packet->storage_channel_properties.flags &
    896 		    STORAGE_CHANNEL_SUPPORTS_MULTI_CHANNEL)
    897 			process_sub_channels = true;
    898 	}
    899 	stor_device->max_transfer_bytes =
    900 		vstor_packet->storage_channel_properties.max_transfer_bytes;
    901 
    902 	if (!is_fc)
    903 		goto done;
    904 
    905 	/*
    906 	 * For FC devices retrieve FC HBA data.
    907 	 */
    908 	memset(vstor_packet, 0, sizeof(struct vstor_packet));
    909 	vstor_packet->operation = VSTOR_OPERATION_FCHBA_DATA;
    910 	ret = storvsc_execute_vstor_op(device, request, true);
    911 	if (ret != 0)
    912 		return ret;
    913 
    914 	/*
    915 	 * Cache the currently active port and node ww names.
    916 	 */
    917 	cache_wwn(stor_device, vstor_packet);
    918 
    919 done:
    920 
    921 	memset(vstor_packet, 0, sizeof(struct vstor_packet));
    922 	vstor_packet->operation = VSTOR_OPERATION_END_INITIALIZATION;
    923 	ret = storvsc_execute_vstor_op(device, request, true);
    924 	if (ret != 0)
    925 		return ret;
    926 
    927 	if (process_sub_channels)
    928 		handle_multichannel_storage(device, max_chns);
    929 
    930 	return ret;
    931 }
    932 
    933 static void storvsc_handle_error(struct vmscsi_request *vm_srb,
    934 				struct scsi_cmnd *scmnd,
    935 				struct Scsi_Host *host,
    936 				u8 asc, u8 ascq)
    937 {
    938 	struct storvsc_scan_work *wrk;
    939 	void (*process_err_fn)(struct work_struct *work);
    940 	struct hv_host_device *host_dev = shost_priv(host);
    941 	bool do_work = false;
    942 
    943 	switch (SRB_STATUS(vm_srb->srb_status)) {
    944 	case SRB_STATUS_ERROR:
    945 		/*
    946 		 * Let upper layer deal with error when
    947 		 * sense message is present.
    948 		 */
    949 
    950 		if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID)
    951 			break;
    952 		/*
    953 		 * If there is an error; offline the device since all
    954 		 * error recovery strategies would have already been
    955 		 * deployed on the host side. However, if the command
    956 		 * were a pass-through command deal with it appropriately.
    957 		 */
    958 		switch (scmnd->cmnd[0]) {
    959 		case ATA_16:
    960 		case ATA_12:
    961 			set_host_byte(scmnd, DID_PASSTHROUGH);
    962 			break;
    963 		/*
    964 		 * On Some Windows hosts TEST_UNIT_READY command can return
    965 		 * SRB_STATUS_ERROR, let the upper level code deal with it
    966 		 * based on the sense information.
    967 		 */
    968 		case TEST_UNIT_READY:
    969 			break;
    970 		default:
    971 			set_host_byte(scmnd, DID_ERROR);
    972 		}
    973 		break;
    974 	case SRB_STATUS_INVALID_LUN:
    975 		set_host_byte(scmnd, DID_NO_CONNECT);
    976 		do_work = true;
    977 		process_err_fn = storvsc_remove_lun;
    978 		break;
    979 	case SRB_STATUS_ABORTED:
    980 		if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID &&
    981 		    (asc == 0x2a) && (ascq == 0x9)) {
    982 			do_work = true;
    983 			process_err_fn = storvsc_device_scan;
    984 			/*
    985 			 * Retry the I/O that trigerred this.
    986 			 */
    987 			set_host_byte(scmnd, DID_REQUEUE);
    988 		}
    989 		break;
    990 	}
    991 
    992 	if (!do_work)
    993 		return;
    994 
    995 	/*
    996 	 * We need to schedule work to process this error; schedule it.
    997 	 */
    998 	wrk = kmalloc(sizeof(struct storvsc_scan_work), GFP_ATOMIC);
    999 	if (!wrk) {
   1000 		set_host_byte(scmnd, DID_TARGET_FAILURE);
   1001 		return;
   1002 	}
   1003 
   1004 	wrk->host = host;
   1005 	wrk->lun = vm_srb->lun;
   1006 	wrk->tgt_id = vm_srb->target_id;
   1007 	INIT_WORK(&wrk->work, process_err_fn);
   1008 	queue_work(host_dev->handle_error_wq, &wrk->work);
   1009 }
   1010 
   1011 
   1012 static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request,
   1013 				       struct storvsc_device *stor_dev)
   1014 {
   1015 	struct scsi_cmnd *scmnd = cmd_request->cmd;
   1016 	struct scsi_sense_hdr sense_hdr;
   1017 	struct vmscsi_request *vm_srb;
   1018 	u32 data_transfer_length;
   1019 	struct Scsi_Host *host;
   1020 	u32 payload_sz = cmd_request->payload_sz;
   1021 	void *payload = cmd_request->payload;
   1022 
   1023 	host = stor_dev->host;
   1024 
   1025 	vm_srb = &cmd_request->vstor_packet.vm_srb;
   1026 	data_transfer_length = vm_srb->data_transfer_length;
   1027 
   1028 	scmnd->result = vm_srb->scsi_status;
   1029 
   1030 	if (scmnd->result) {
   1031 		if (scsi_normalize_sense(scmnd->sense_buffer,
   1032 				SCSI_SENSE_BUFFERSIZE, &sense_hdr) &&
   1033 		    !(sense_hdr.sense_key == NOT_READY &&
   1034 				 sense_hdr.asc == 0x03A) &&
   1035 		    do_logging(STORVSC_LOGGING_ERROR))
   1036 			scsi_print_sense_hdr(scmnd->device, "storvsc",
   1037 					     &sense_hdr);
   1038 	}
   1039 
   1040 	if (vm_srb->srb_status != SRB_STATUS_SUCCESS) {
   1041 		storvsc_handle_error(vm_srb, scmnd, host, sense_hdr.asc,
   1042 					 sense_hdr.ascq);
   1043 		/*
   1044 		 * The Windows driver set data_transfer_length on
   1045 		 * SRB_STATUS_DATA_OVERRUN. On other errors, this value
   1046 		 * is untouched.  In these cases we set it to 0.
   1047 		 */
   1048 		if (vm_srb->srb_status != SRB_STATUS_DATA_OVERRUN)
   1049 			data_transfer_length = 0;
   1050 	}
   1051 
   1052 	scsi_set_resid(scmnd,
   1053 		cmd_request->payload->range.len - data_transfer_length);
   1054 
   1055 	scmnd->scsi_done(scmnd);
   1056 
   1057 	if (payload_sz >
   1058 		sizeof(struct vmbus_channel_packet_multipage_buffer))
   1059 		kfree(payload);
   1060 }
   1061 
   1062 static void storvsc_on_io_completion(struct storvsc_device *stor_device,
   1063 				  struct vstor_packet *vstor_packet,
   1064 				  struct storvsc_cmd_request *request)
   1065 {
   1066 	struct vstor_packet *stor_pkt;
   1067 	struct hv_device *device = stor_device->device;
   1068 
   1069 	stor_pkt = &request->vstor_packet;
   1070 
   1071 	/*
   1072 	 * The current SCSI handling on the host side does
   1073 	 * not correctly handle:
   1074 	 * INQUIRY command with page code parameter set to 0x80
   1075 	 * MODE_SENSE command with cmd[2] == 0x1c
   1076 	 *
   1077 	 * Setup srb and scsi status so this won't be fatal.
   1078 	 * We do this so we can distinguish truly fatal failues
   1079 	 * (srb status == 0x4) and off-line the device in that case.
   1080 	 */
   1081 
   1082 	if ((stor_pkt->vm_srb.cdb[0] == INQUIRY) ||
   1083 	   (stor_pkt->vm_srb.cdb[0] == MODE_SENSE)) {
   1084 		vstor_packet->vm_srb.scsi_status = 0;
   1085 		vstor_packet->vm_srb.srb_status = SRB_STATUS_SUCCESS;
   1086 	}
   1087 
   1088 
   1089 	/* Copy over the status...etc */
   1090 	stor_pkt->vm_srb.scsi_status = vstor_packet->vm_srb.scsi_status;
   1091 	stor_pkt->vm_srb.srb_status = vstor_packet->vm_srb.srb_status;
   1092 	stor_pkt->vm_srb.sense_info_length =
   1093 	vstor_packet->vm_srb.sense_info_length;
   1094 
   1095 	if (vstor_packet->vm_srb.scsi_status != 0 ||
   1096 	    vstor_packet->vm_srb.srb_status != SRB_STATUS_SUCCESS)
   1097 		storvsc_log(device, STORVSC_LOGGING_WARN,
   1098 			"cmd 0x%x scsi status 0x%x srb status 0x%x\n",
   1099 			stor_pkt->vm_srb.cdb[0],
   1100 			vstor_packet->vm_srb.scsi_status,
   1101 			vstor_packet->vm_srb.srb_status);
   1102 
   1103 	if ((vstor_packet->vm_srb.scsi_status & 0xFF) == 0x02) {
   1104 		/* CHECK_CONDITION */
   1105 		if (vstor_packet->vm_srb.srb_status &
   1106 			SRB_STATUS_AUTOSENSE_VALID) {
   1107 			/* autosense data available */
   1108 
   1109 			storvsc_log(device, STORVSC_LOGGING_WARN,
   1110 				"stor pkt %p autosense data valid - len %d\n",
   1111 				request, vstor_packet->vm_srb.sense_info_length);
   1112 
   1113 			memcpy(request->cmd->sense_buffer,
   1114 			       vstor_packet->vm_srb.sense_data,
   1115 			       vstor_packet->vm_srb.sense_info_length);
   1116 
   1117 		}
   1118 	}
   1119 
   1120 	stor_pkt->vm_srb.data_transfer_length =
   1121 	vstor_packet->vm_srb.data_transfer_length;
   1122 
   1123 	storvsc_command_completion(request, stor_device);
   1124 
   1125 	if (atomic_dec_and_test(&stor_device->num_outstanding_req) &&
   1126 		stor_device->drain_notify)
   1127 		wake_up(&stor_device->waiting_to_drain);
   1128 
   1129 
   1130 }
   1131 
   1132 static void storvsc_on_receive(struct storvsc_device *stor_device,
   1133 			     struct vstor_packet *vstor_packet,
   1134 			     struct storvsc_cmd_request *request)
   1135 {
   1136 	struct hv_host_device *host_dev;
   1137 	switch (vstor_packet->operation) {
   1138 	case VSTOR_OPERATION_COMPLETE_IO:
   1139 		storvsc_on_io_completion(stor_device, vstor_packet, request);
   1140 		break;
   1141 
   1142 	case VSTOR_OPERATION_REMOVE_DEVICE:
   1143 	case VSTOR_OPERATION_ENUMERATE_BUS:
   1144 		host_dev = shost_priv(stor_device->host);
   1145 		queue_work(
   1146 			host_dev->handle_error_wq, &host_dev->host_scan_work);
   1147 		break;
   1148 
   1149 	case VSTOR_OPERATION_FCHBA_DATA:
   1150 		cache_wwn(stor_device, vstor_packet);
   1151 #if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
   1152 		fc_host_node_name(stor_device->host) = stor_device->node_name;
   1153 		fc_host_port_name(stor_device->host) = stor_device->port_name;
   1154 #endif
   1155 		break;
   1156 	default:
   1157 		break;
   1158 	}
   1159 }
   1160 
   1161 static void storvsc_on_channel_callback(void *context)
   1162 {
   1163 	struct vmbus_channel *channel = (struct vmbus_channel *)context;
   1164 	const struct vmpacket_descriptor *desc;
   1165 	struct hv_device *device;
   1166 	struct storvsc_device *stor_device;
   1167 
   1168 	if (channel->primary_channel != NULL)
   1169 		device = channel->primary_channel->device_obj;
   1170 	else
   1171 		device = channel->device_obj;
   1172 
   1173 	stor_device = get_in_stor_device(device);
   1174 	if (!stor_device)
   1175 		return;
   1176 
   1177 	foreach_vmbus_pkt(desc, channel) {
   1178 		void *packet = hv_pkt_data(desc);
   1179 		struct storvsc_cmd_request *request;
   1180 
   1181 		request = (struct storvsc_cmd_request *)
   1182 			((unsigned long)desc->trans_id);
   1183 
   1184 		if (request == &stor_device->init_request ||
   1185 		    request == &stor_device->reset_request) {
   1186 			memcpy(&request->vstor_packet, packet,
   1187 			       (sizeof(struct vstor_packet) - vmscsi_size_delta));
   1188 			complete(&request->wait_event);
   1189 		} else {
   1190 			storvsc_on_receive(stor_device, packet, request);
   1191 		}
   1192 	}
   1193 }
   1194 
   1195 static int storvsc_connect_to_vsp(struct hv_device *device, u32 ring_size,
   1196 				  bool is_fc)
   1197 {
   1198 	struct vmstorage_channel_properties props;
   1199 	int ret;
   1200 
   1201 	memset(&props, 0, sizeof(struct vmstorage_channel_properties));
   1202 
   1203 	ret = vmbus_open(device->channel,
   1204 			 ring_size,
   1205 			 ring_size,
   1206 			 (void *)&props,
   1207 			 sizeof(struct vmstorage_channel_properties),
   1208 			 storvsc_on_channel_callback, device->channel);
   1209 
   1210 	if (ret != 0)
   1211 		return ret;
   1212 
   1213 	ret = storvsc_channel_init(device, is_fc);
   1214 
   1215 	return ret;
   1216 }
   1217 
   1218 static int storvsc_dev_remove(struct hv_device *device)
   1219 {
   1220 	struct storvsc_device *stor_device;
   1221 
   1222 	stor_device = hv_get_drvdata(device);
   1223 
   1224 	stor_device->destroy = true;
   1225 
   1226 	/* Make sure flag is set before waiting */
   1227 	wmb();
   1228 
   1229 	/*
   1230 	 * At this point, all outbound traffic should be disable. We
   1231 	 * only allow inbound traffic (responses) to proceed so that
   1232 	 * outstanding requests can be completed.
   1233 	 */
   1234 
   1235 	storvsc_wait_to_drain(stor_device);
   1236 
   1237 	/*
   1238 	 * Since we have already drained, we don't need to busy wait
   1239 	 * as was done in final_release_stor_device()
   1240 	 * Note that we cannot set the ext pointer to NULL until
   1241 	 * we have drained - to drain the outgoing packets, we need to
   1242 	 * allow incoming packets.
   1243 	 */
   1244 	hv_set_drvdata(device, NULL);
   1245 
   1246 	/* Close the channel */
   1247 	vmbus_close(device->channel);
   1248 
   1249 	kfree(stor_device->stor_chns);
   1250 	kfree(stor_device);
   1251 	return 0;
   1252 }
   1253 
   1254 static struct vmbus_channel *get_og_chn(struct storvsc_device *stor_device,
   1255 					u16 q_num)
   1256 {
   1257 	u16 slot = 0;
   1258 	u16 hash_qnum;
   1259 	const struct cpumask *node_mask;
   1260 	int num_channels, tgt_cpu;
   1261 
   1262 	if (stor_device->num_sc == 0)
   1263 		return stor_device->device->channel;
   1264 
   1265 	/*
   1266 	 * Our channel array is sparsley populated and we
   1267 	 * initiated I/O on a processor/hw-q that does not
   1268 	 * currently have a designated channel. Fix this.
   1269 	 * The strategy is simple:
   1270 	 * I. Ensure NUMA locality
   1271 	 * II. Distribute evenly (best effort)
   1272 	 * III. Mapping is persistent.
   1273 	 */
   1274 
   1275 	node_mask = cpumask_of_node(cpu_to_node(q_num));
   1276 
   1277 	num_channels = 0;
   1278 	for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
   1279 		if (cpumask_test_cpu(tgt_cpu, node_mask))
   1280 			num_channels++;
   1281 	}
   1282 	if (num_channels == 0)
   1283 		return stor_device->device->channel;
   1284 
   1285 	hash_qnum = q_num;
   1286 	while (hash_qnum >= num_channels)
   1287 		hash_qnum -= num_channels;
   1288 
   1289 	for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
   1290 		if (!cpumask_test_cpu(tgt_cpu, node_mask))
   1291 			continue;
   1292 		if (slot == hash_qnum)
   1293 			break;
   1294 		slot++;
   1295 	}
   1296 
   1297 	stor_device->stor_chns[q_num] = stor_device->stor_chns[tgt_cpu];
   1298 
   1299 	return stor_device->stor_chns[q_num];
   1300 }
   1301 
   1302 
   1303 static int storvsc_do_io(struct hv_device *device,
   1304 			 struct storvsc_cmd_request *request, u16 q_num)
   1305 {
   1306 	struct storvsc_device *stor_device;
   1307 	struct vstor_packet *vstor_packet;
   1308 	struct vmbus_channel *outgoing_channel, *channel;
   1309 	int ret = 0;
   1310 	const struct cpumask *node_mask;
   1311 	int tgt_cpu;
   1312 
   1313 	vstor_packet = &request->vstor_packet;
   1314 	stor_device = get_out_stor_device(device);
   1315 
   1316 	if (!stor_device)
   1317 		return -ENODEV;
   1318 
   1319 
   1320 	request->device  = device;
   1321 	/*
   1322 	 * Select an an appropriate channel to send the request out.
   1323 	 */
   1324 	if (stor_device->stor_chns[q_num] != NULL) {
   1325 		outgoing_channel = stor_device->stor_chns[q_num];
   1326 		if (outgoing_channel->target_cpu == q_num) {
   1327 			/*
   1328 			 * Ideally, we want to pick a different channel if
   1329 			 * available on the same NUMA node.
   1330 			 */
   1331 			node_mask = cpumask_of_node(cpu_to_node(q_num));
   1332 			for_each_cpu_wrap(tgt_cpu,
   1333 				 &stor_device->alloced_cpus, q_num + 1) {
   1334 				if (!cpumask_test_cpu(tgt_cpu, node_mask))
   1335 					continue;
   1336 				if (tgt_cpu == q_num)
   1337 					continue;
   1338 				channel = stor_device->stor_chns[tgt_cpu];
   1339 				if (hv_get_avail_to_write_percent(
   1340 							&channel->outbound)
   1341 						> ring_avail_percent_lowater) {
   1342 					outgoing_channel = channel;
   1343 					goto found_channel;
   1344 				}
   1345 			}
   1346 
   1347 			/*
   1348 			 * All the other channels on the same NUMA node are
   1349 			 * busy. Try to use the channel on the current CPU
   1350 			 */
   1351 			if (hv_get_avail_to_write_percent(
   1352 						&outgoing_channel->outbound)
   1353 					> ring_avail_percent_lowater)
   1354 				goto found_channel;
   1355 
   1356 			/*
   1357 			 * If we reach here, all the channels on the current
   1358 			 * NUMA node are busy. Try to find a channel in
   1359 			 * other NUMA nodes
   1360 			 */
   1361 			for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
   1362 				if (cpumask_test_cpu(tgt_cpu, node_mask))
   1363 					continue;
   1364 				channel = stor_device->stor_chns[tgt_cpu];
   1365 				if (hv_get_avail_to_write_percent(
   1366 							&channel->outbound)
   1367 						> ring_avail_percent_lowater) {
   1368 					outgoing_channel = channel;
   1369 					goto found_channel;
   1370 				}
   1371 			}
   1372 		}
   1373 	} else {
   1374 		outgoing_channel = get_og_chn(stor_device, q_num);
   1375 	}
   1376 
   1377 found_channel:
   1378 	vstor_packet->flags |= REQUEST_COMPLETION_FLAG;
   1379 
   1380 	vstor_packet->vm_srb.length = (sizeof(struct vmscsi_request) -
   1381 					vmscsi_size_delta);
   1382 
   1383 
   1384 	vstor_packet->vm_srb.sense_info_length = sense_buffer_size;
   1385 
   1386 
   1387 	vstor_packet->vm_srb.data_transfer_length =
   1388 	request->payload->range.len;
   1389 
   1390 	vstor_packet->operation = VSTOR_OPERATION_EXECUTE_SRB;
   1391 
   1392 	if (request->payload->range.len) {
   1393 
   1394 		ret = vmbus_sendpacket_mpb_desc(outgoing_channel,
   1395 				request->payload, request->payload_sz,
   1396 				vstor_packet,
   1397 				(sizeof(struct vstor_packet) -
   1398 				vmscsi_size_delta),
   1399 				(unsigned long)request);
   1400 	} else {
   1401 		ret = vmbus_sendpacket(outgoing_channel, vstor_packet,
   1402 			       (sizeof(struct vstor_packet) -
   1403 				vmscsi_size_delta),
   1404 			       (unsigned long)request,
   1405 			       VM_PKT_DATA_INBAND,
   1406 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
   1407 	}
   1408 
   1409 	if (ret != 0)
   1410 		return ret;
   1411 
   1412 	atomic_inc(&stor_device->num_outstanding_req);
   1413 
   1414 	return ret;
   1415 }
   1416 
   1417 static int storvsc_device_alloc(struct scsi_device *sdevice)
   1418 {
   1419 	/*
   1420 	 * Set blist flag to permit the reading of the VPD pages even when
   1421 	 * the target may claim SPC-2 compliance. MSFT targets currently
   1422 	 * claim SPC-2 compliance while they implement post SPC-2 features.
   1423 	 * With this flag we can correctly handle WRITE_SAME_16 issues.
   1424 	 *
   1425 	 * Hypervisor reports SCSI_UNKNOWN type for DVD ROM device but
   1426 	 * still supports REPORT LUN.
   1427 	 */
   1428 	sdevice->sdev_bflags = BLIST_REPORTLUN2 | BLIST_TRY_VPD_PAGES;
   1429 
   1430 	return 0;
   1431 }
   1432 
   1433 static int storvsc_device_configure(struct scsi_device *sdevice)
   1434 {
   1435 	blk_queue_rq_timeout(sdevice->request_queue, (storvsc_timeout * HZ));
   1436 
   1437 	/* Ensure there are no gaps in presented sgls */
   1438 	blk_queue_virt_boundary(sdevice->request_queue, PAGE_SIZE - 1);
   1439 
   1440 	sdevice->no_write_same = 1;
   1441 
   1442 	/*
   1443 	 * If the host is WIN8 or WIN8 R2, claim conformance to SPC-3
   1444 	 * if the device is a MSFT virtual device.  If the host is
   1445 	 * WIN10 or newer, allow write_same.
   1446 	 */
   1447 	if (!strncmp(sdevice->vendor, "Msft", 4)) {
   1448 		switch (vmstor_proto_version) {
   1449 		case VMSTOR_PROTO_VERSION_WIN8:
   1450 		case VMSTOR_PROTO_VERSION_WIN8_1:
   1451 			sdevice->scsi_level = SCSI_SPC_3;
   1452 			break;
   1453 		}
   1454 
   1455 		if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN10)
   1456 			sdevice->no_write_same = 0;
   1457 	}
   1458 
   1459 	return 0;
   1460 }
   1461 
   1462 static int storvsc_get_chs(struct scsi_device *sdev, struct block_device * bdev,
   1463 			   sector_t capacity, int *info)
   1464 {
   1465 	sector_t nsect = capacity;
   1466 	sector_t cylinders = nsect;
   1467 	int heads, sectors_pt;
   1468 
   1469 	/*
   1470 	 * We are making up these values; let us keep it simple.
   1471 	 */
   1472 	heads = 0xff;
   1473 	sectors_pt = 0x3f;      /* Sectors per track */
   1474 	sector_div(cylinders, heads * sectors_pt);
   1475 	if ((sector_t)(cylinders + 1) * heads * sectors_pt < nsect)
   1476 		cylinders = 0xffff;
   1477 
   1478 	info[0] = heads;
   1479 	info[1] = sectors_pt;
   1480 	info[2] = (int)cylinders;
   1481 
   1482 	return 0;
   1483 }
   1484 
   1485 static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
   1486 {
   1487 	struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
   1488 	struct hv_device *device = host_dev->dev;
   1489 
   1490 	struct storvsc_device *stor_device;
   1491 	struct storvsc_cmd_request *request;
   1492 	struct vstor_packet *vstor_packet;
   1493 	int ret, t;
   1494 
   1495 
   1496 	stor_device = get_out_stor_device(device);
   1497 	if (!stor_device)
   1498 		return FAILED;
   1499 
   1500 	request = &stor_device->reset_request;
   1501 	vstor_packet = &request->vstor_packet;
   1502 
   1503 	init_completion(&request->wait_event);
   1504 
   1505 	vstor_packet->operation = VSTOR_OPERATION_RESET_BUS;
   1506 	vstor_packet->flags = REQUEST_COMPLETION_FLAG;
   1507 	vstor_packet->vm_srb.path_id = stor_device->path_id;
   1508 
   1509 	ret = vmbus_sendpacket(device->channel, vstor_packet,
   1510 			       (sizeof(struct vstor_packet) -
   1511 				vmscsi_size_delta),
   1512 			       (unsigned long)&stor_device->reset_request,
   1513 			       VM_PKT_DATA_INBAND,
   1514 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
   1515 	if (ret != 0)
   1516 		return FAILED;
   1517 
   1518 	t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
   1519 	if (t == 0)
   1520 		return TIMEOUT_ERROR;
   1521 
   1522 
   1523 	/*
   1524 	 * At this point, all outstanding requests in the adapter
   1525 	 * should have been flushed out and return to us
   1526 	 * There is a potential race here where the host may be in
   1527 	 * the process of responding when we return from here.
   1528 	 * Just wait for all in-transit packets to be accounted for
   1529 	 * before we return from here.
   1530 	 */
   1531 	storvsc_wait_to_drain(stor_device);
   1532 
   1533 	return SUCCESS;
   1534 }
   1535 
   1536 /*
   1537  * The host guarantees to respond to each command, although I/O latencies might
   1538  * be unbounded on Azure.  Reset the timer unconditionally to give the host a
   1539  * chance to perform EH.
   1540  */
   1541 static enum blk_eh_timer_return storvsc_eh_timed_out(struct scsi_cmnd *scmnd)
   1542 {
   1543 #if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
   1544 	if (scmnd->device->host->transportt == fc_transport_template)
   1545 		return fc_eh_timed_out(scmnd);
   1546 #endif
   1547 	return BLK_EH_RESET_TIMER;
   1548 }
   1549 
   1550 static bool storvsc_scsi_cmd_ok(struct scsi_cmnd *scmnd)
   1551 {
   1552 	bool allowed = true;
   1553 	u8 scsi_op = scmnd->cmnd[0];
   1554 
   1555 	switch (scsi_op) {
   1556 	/* the host does not handle WRITE_SAME, log accident usage */
   1557 	case WRITE_SAME:
   1558 	/*
   1559 	 * smartd sends this command and the host does not handle
   1560 	 * this. So, don't send it.
   1561 	 */
   1562 	case SET_WINDOW:
   1563 		scmnd->result = ILLEGAL_REQUEST << 16;
   1564 		allowed = false;
   1565 		break;
   1566 	default:
   1567 		break;
   1568 	}
   1569 	return allowed;
   1570 }
   1571 
   1572 static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
   1573 {
   1574 	int ret;
   1575 	struct hv_host_device *host_dev = shost_priv(host);
   1576 	struct hv_device *dev = host_dev->dev;
   1577 	struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd);
   1578 	int i;
   1579 	struct scatterlist *sgl;
   1580 	unsigned int sg_count = 0;
   1581 	struct vmscsi_request *vm_srb;
   1582 	struct scatterlist *cur_sgl;
   1583 	struct vmbus_packet_mpb_array  *payload;
   1584 	u32 payload_sz;
   1585 	u32 length;
   1586 
   1587 	if (vmstor_proto_version <= VMSTOR_PROTO_VERSION_WIN8) {
   1588 		/*
   1589 		 * On legacy hosts filter unimplemented commands.
   1590 		 * Future hosts are expected to correctly handle
   1591 		 * unsupported commands. Furthermore, it is
   1592 		 * possible that some of the currently
   1593 		 * unsupported commands maybe supported in
   1594 		 * future versions of the host.
   1595 		 */
   1596 		if (!storvsc_scsi_cmd_ok(scmnd)) {
   1597 			scmnd->scsi_done(scmnd);
   1598 			return 0;
   1599 		}
   1600 	}
   1601 
   1602 	/* Setup the cmd request */
   1603 	cmd_request->cmd = scmnd;
   1604 
   1605 	vm_srb = &cmd_request->vstor_packet.vm_srb;
   1606 	vm_srb->win8_extension.time_out_value = 60;
   1607 
   1608 	vm_srb->win8_extension.srb_flags |=
   1609 		SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
   1610 
   1611 	if (scmnd->device->tagged_supported) {
   1612 		vm_srb->win8_extension.srb_flags |=
   1613 		(SRB_FLAGS_QUEUE_ACTION_ENABLE | SRB_FLAGS_NO_QUEUE_FREEZE);
   1614 		vm_srb->win8_extension.queue_tag = SP_UNTAGGED;
   1615 		vm_srb->win8_extension.queue_action = SRB_SIMPLE_TAG_REQUEST;
   1616 	}
   1617 
   1618 	/* Build the SRB */
   1619 	switch (scmnd->sc_data_direction) {
   1620 	case DMA_TO_DEVICE:
   1621 		vm_srb->data_in = WRITE_TYPE;
   1622 		vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_OUT;
   1623 		break;
   1624 	case DMA_FROM_DEVICE:
   1625 		vm_srb->data_in = READ_TYPE;
   1626 		vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_IN;
   1627 		break;
   1628 	case DMA_NONE:
   1629 		vm_srb->data_in = UNKNOWN_TYPE;
   1630 		vm_srb->win8_extension.srb_flags |= SRB_FLAGS_NO_DATA_TRANSFER;
   1631 		break;
   1632 	default:
   1633 		/*
   1634 		 * This is DMA_BIDIRECTIONAL or something else we are never
   1635 		 * supposed to see here.
   1636 		 */
   1637 		WARN(1, "Unexpected data direction: %d\n",
   1638 		     scmnd->sc_data_direction);
   1639 		return -EINVAL;
   1640 	}
   1641 
   1642 
   1643 	vm_srb->port_number = host_dev->port;
   1644 	vm_srb->path_id = scmnd->device->channel;
   1645 	vm_srb->target_id = scmnd->device->id;
   1646 	vm_srb->lun = scmnd->device->lun;
   1647 
   1648 	vm_srb->cdb_length = scmnd->cmd_len;
   1649 
   1650 	memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length);
   1651 
   1652 	sgl = (struct scatterlist *)scsi_sglist(scmnd);
   1653 	sg_count = scsi_sg_count(scmnd);
   1654 
   1655 	length = scsi_bufflen(scmnd);
   1656 	payload = (struct vmbus_packet_mpb_array *)&cmd_request->mpb;
   1657 	payload_sz = sizeof(cmd_request->mpb);
   1658 
   1659 	if (sg_count) {
   1660 		if (sg_count > MAX_PAGE_BUFFER_COUNT) {
   1661 
   1662 			payload_sz = (sg_count * sizeof(u64) +
   1663 				      sizeof(struct vmbus_packet_mpb_array));
   1664 			payload = kzalloc(payload_sz, GFP_ATOMIC);
   1665 			if (!payload)
   1666 				return SCSI_MLQUEUE_DEVICE_BUSY;
   1667 		}
   1668 
   1669 		payload->range.len = length;
   1670 		payload->range.offset = sgl[0].offset;
   1671 
   1672 		cur_sgl = sgl;
   1673 		for (i = 0; i < sg_count; i++) {
   1674 			payload->range.pfn_array[i] =
   1675 				page_to_pfn(sg_page((cur_sgl)));
   1676 			cur_sgl = sg_next(cur_sgl);
   1677 		}
   1678 	}
   1679 
   1680 	cmd_request->payload = payload;
   1681 	cmd_request->payload_sz = payload_sz;
   1682 
   1683 	/* Invokes the vsc to start an IO */
   1684 	ret = storvsc_do_io(dev, cmd_request, get_cpu());
   1685 	put_cpu();
   1686 
   1687 	if (ret == -EAGAIN) {
   1688 		if (payload_sz > sizeof(cmd_request->mpb))
   1689 			kfree(payload);
   1690 		/* no more space */
   1691 		return SCSI_MLQUEUE_DEVICE_BUSY;
   1692 	}
   1693 
   1694 	return 0;
   1695 }
   1696 
   1697 static struct scsi_host_template scsi_driver = {
   1698 	.module	=		THIS_MODULE,
   1699 	.name =			"storvsc_host_t",
   1700 	.cmd_size =             sizeof(struct storvsc_cmd_request),
   1701 	.bios_param =		storvsc_get_chs,
   1702 	.queuecommand =		storvsc_queuecommand,
   1703 	.eh_host_reset_handler =	storvsc_host_reset_handler,
   1704 	.proc_name =		"storvsc_host",
   1705 	.eh_timed_out =		storvsc_eh_timed_out,
   1706 	.slave_alloc =		storvsc_device_alloc,
   1707 	.slave_configure =	storvsc_device_configure,
   1708 	.cmd_per_lun =		2048,
   1709 	.this_id =		-1,
   1710 	/* Make sure we dont get a sg segment crosses a page boundary */
   1711 	.dma_boundary =		PAGE_SIZE-1,
   1712 	.no_write_same =	1,
   1713 	.track_queue_depth =	1,
   1714 };
   1715 
   1716 enum {
   1717 	SCSI_GUID,
   1718 	IDE_GUID,
   1719 	SFC_GUID,
   1720 };
   1721 
   1722 static const struct hv_vmbus_device_id id_table[] = {
   1723 	/* SCSI guid */
   1724 	{ HV_SCSI_GUID,
   1725 	  .driver_data = SCSI_GUID
   1726 	},
   1727 	/* IDE guid */
   1728 	{ HV_IDE_GUID,
   1729 	  .driver_data = IDE_GUID
   1730 	},
   1731 	/* Fibre Channel GUID */
   1732 	{
   1733 	  HV_SYNTHFC_GUID,
   1734 	  .driver_data = SFC_GUID
   1735 	},
   1736 	{ },
   1737 };
   1738 
   1739 MODULE_DEVICE_TABLE(vmbus, id_table);
   1740 
   1741 static int storvsc_probe(struct hv_device *device,
   1742 			const struct hv_vmbus_device_id *dev_id)
   1743 {
   1744 	int ret;
   1745 	int num_cpus = num_online_cpus();
   1746 	struct Scsi_Host *host;
   1747 	struct hv_host_device *host_dev;
   1748 	bool dev_is_ide = ((dev_id->driver_data == IDE_GUID) ? true : false);
   1749 	bool is_fc = ((dev_id->driver_data == SFC_GUID) ? true : false);
   1750 	int target = 0;
   1751 	struct storvsc_device *stor_device;
   1752 	int max_luns_per_target;
   1753 	int max_targets;
   1754 	int max_channels;
   1755 	int max_sub_channels = 0;
   1756 
   1757 	/*
   1758 	 * Based on the windows host we are running on,
   1759 	 * set state to properly communicate with the host.
   1760 	 */
   1761 
   1762 	if (vmbus_proto_version < VERSION_WIN8) {
   1763 		max_luns_per_target = STORVSC_IDE_MAX_LUNS_PER_TARGET;
   1764 		max_targets = STORVSC_IDE_MAX_TARGETS;
   1765 		max_channels = STORVSC_IDE_MAX_CHANNELS;
   1766 	} else {
   1767 		max_luns_per_target = STORVSC_MAX_LUNS_PER_TARGET;
   1768 		max_targets = STORVSC_MAX_TARGETS;
   1769 		max_channels = STORVSC_MAX_CHANNELS;
   1770 		/*
   1771 		 * On Windows8 and above, we support sub-channels for storage
   1772 		 * on SCSI and FC controllers.
   1773 		 * The number of sub-channels offerred is based on the number of
   1774 		 * VCPUs in the guest.
   1775 		 */
   1776 		if (!dev_is_ide)
   1777 			max_sub_channels =
   1778 				(num_cpus - 1) / storvsc_vcpus_per_sub_channel;
   1779 	}
   1780 
   1781 	scsi_driver.can_queue = max_outstanding_req_per_channel *
   1782 				(max_sub_channels + 1) *
   1783 				(100 - ring_avail_percent_lowater) / 100;
   1784 
   1785 	host = scsi_host_alloc(&scsi_driver,
   1786 			       sizeof(struct hv_host_device));
   1787 	if (!host)
   1788 		return -ENOMEM;
   1789 
   1790 	host_dev = shost_priv(host);
   1791 	memset(host_dev, 0, sizeof(struct hv_host_device));
   1792 
   1793 	host_dev->port = host->host_no;
   1794 	host_dev->dev = device;
   1795 	host_dev->host = host;
   1796 
   1797 
   1798 	stor_device = kzalloc(sizeof(struct storvsc_device), GFP_KERNEL);
   1799 	if (!stor_device) {
   1800 		ret = -ENOMEM;
   1801 		goto err_out0;
   1802 	}
   1803 
   1804 	stor_device->destroy = false;
   1805 	init_waitqueue_head(&stor_device->waiting_to_drain);
   1806 	stor_device->device = device;
   1807 	stor_device->host = host;
   1808 	hv_set_drvdata(device, stor_device);
   1809 
   1810 	stor_device->port_number = host->host_no;
   1811 	ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size, is_fc);
   1812 	if (ret)
   1813 		goto err_out1;
   1814 
   1815 	host_dev->path = stor_device->path_id;
   1816 	host_dev->target = stor_device->target_id;
   1817 
   1818 	switch (dev_id->driver_data) {
   1819 	case SFC_GUID:
   1820 		host->max_lun = STORVSC_FC_MAX_LUNS_PER_TARGET;
   1821 		host->max_id = STORVSC_FC_MAX_TARGETS;
   1822 		host->max_channel = STORVSC_FC_MAX_CHANNELS - 1;
   1823 #if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
   1824 		host->transportt = fc_transport_template;
   1825 #endif
   1826 		break;
   1827 
   1828 	case SCSI_GUID:
   1829 		host->max_lun = max_luns_per_target;
   1830 		host->max_id = max_targets;
   1831 		host->max_channel = max_channels - 1;
   1832 		break;
   1833 
   1834 	default:
   1835 		host->max_lun = STORVSC_IDE_MAX_LUNS_PER_TARGET;
   1836 		host->max_id = STORVSC_IDE_MAX_TARGETS;
   1837 		host->max_channel = STORVSC_IDE_MAX_CHANNELS - 1;
   1838 		break;
   1839 	}
   1840 	/* max cmd length */
   1841 	host->max_cmd_len = STORVSC_MAX_CMD_LEN;
   1842 
   1843 	/*
   1844 	 * set the table size based on the info we got
   1845 	 * from the host.
   1846 	 */
   1847 	host->sg_tablesize = (stor_device->max_transfer_bytes >> PAGE_SHIFT);
   1848 	/*
   1849 	 * Set the number of HW queues we are supporting.
   1850 	 */
   1851 	if (stor_device->num_sc != 0)
   1852 		host->nr_hw_queues = stor_device->num_sc + 1;
   1853 
   1854 	/*
   1855 	 * Set the error handler work queue.
   1856 	 */
   1857 	host_dev->handle_error_wq =
   1858 			alloc_ordered_workqueue("storvsc_error_wq_%d",
   1859 						WQ_MEM_RECLAIM,
   1860 						host->host_no);
   1861 	if (!host_dev->handle_error_wq)
   1862 		goto err_out2;
   1863 	INIT_WORK(&host_dev->host_scan_work, storvsc_host_scan);
   1864 	/* Register the HBA and start the scsi bus scan */
   1865 	ret = scsi_add_host(host, &device->device);
   1866 	if (ret != 0)
   1867 		goto err_out3;
   1868 
   1869 	if (!dev_is_ide) {
   1870 		scsi_scan_host(host);
   1871 	} else {
   1872 		target = (device->dev_instance.b[5] << 8 |
   1873 			 device->dev_instance.b[4]);
   1874 		ret = scsi_add_device(host, 0, target, 0);
   1875 		if (ret)
   1876 			goto err_out4;
   1877 	}
   1878 #if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
   1879 	if (host->transportt == fc_transport_template) {
   1880 		struct fc_rport_identifiers ids = {
   1881 			.roles = FC_PORT_ROLE_FCP_DUMMY_INITIATOR,
   1882 		};
   1883 
   1884 		fc_host_node_name(host) = stor_device->node_name;
   1885 		fc_host_port_name(host) = stor_device->port_name;
   1886 		stor_device->rport = fc_remote_port_add(host, 0, &ids);
   1887 		if (!stor_device->rport) {
   1888 			ret = -ENOMEM;
   1889 			goto err_out4;
   1890 		}
   1891 	}
   1892 #endif
   1893 	return 0;
   1894 
   1895 err_out4:
   1896 	scsi_remove_host(host);
   1897 
   1898 err_out3:
   1899 	destroy_workqueue(host_dev->handle_error_wq);
   1900 
   1901 err_out2:
   1902 	/*
   1903 	 * Once we have connected with the host, we would need to
   1904 	 * to invoke storvsc_dev_remove() to rollback this state and
   1905 	 * this call also frees up the stor_device; hence the jump around
   1906 	 * err_out1 label.
   1907 	 */
   1908 	storvsc_dev_remove(device);
   1909 	goto err_out0;
   1910 
   1911 err_out1:
   1912 	kfree(stor_device->stor_chns);
   1913 	kfree(stor_device);
   1914 
   1915 err_out0:
   1916 	scsi_host_put(host);
   1917 	return ret;
   1918 }
   1919 
   1920 static 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 
   1940 static 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)
   1951 static struct fc_function_template fc_transport_functions = {
   1952 	.show_host_node_name = 1,
   1953 	.show_host_port_name = 1,
   1954 };
   1955 #endif
   1956 
   1957 static 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 
   1990 static 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 
   1998 MODULE_LICENSE("GPL");
   1999 MODULE_DESCRIPTION("Microsoft Hyper-V virtual storage driver");
   2000 module_init(storvsc_drv_init);
   2001 module_exit(storvsc_drv_exit);