blob: 00bb4bdffe852105ddd7fa0481fc257b427e3489 [file] [log] [blame]
Hank Janssenbef4a342009-07-13 16:01:31 -07001/*
Hank Janssenbef4a342009-07-13 16:01:31 -07002 * 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>
K. Y. Srinivasan972621c2011-05-10 07:54:19 -070020 * K. Y. Srinivasan <kys@microsoft.com>
Hank Janssenbef4a342009-07-13 16:01:31 -070021 */
K. Y. Srinivasana1be1702011-08-27 11:31:23 -070022
23#include <linux/kernel.h>
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -070024#include <linux/wait.h>
K. Y. Srinivasana1be1702011-08-27 11:31:23 -070025#include <linux/sched.h>
26#include <linux/completion.h>
27#include <linux/string.h>
28#include <linux/mm.h>
29#include <linux/delay.h>
Hank Janssenbef4a342009-07-13 16:01:31 -070030#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
Hank Janssenbef4a342009-07-13 16:01:31 -070032#include <linux/module.h>
33#include <linux/device.h>
Greg Kroah-Hartman46a97192011-10-04 12:29:52 -070034#include <linux/hyperv.h>
K. Y. Srinivasan56b26e62014-07-12 09:48:30 -070035#include <linux/blkdev.h>
Hank Janssenbef4a342009-07-13 16:01:31 -070036#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>
Hank Janssenbef4a342009-07-13 16:01:31 -070043#include <scsi/scsi_dbg.h>
K. Y. Srinivasan3f335ea2011-05-12 19:34:15 -070044
K. Y. Srinivasanc6491142012-01-12 12:38:03 -080045/*
K. Y. Srinivasanaf9584b2012-01-12 12:38:08 -080046 * All wire protocol details (storage protocol between the guest and the host)
47 * are consolidated here.
48 *
49 * Begin protocol definitions.
K. Y. Srinivasanc6491142012-01-12 12:38:03 -080050 */
51
K. Y. Srinivasan09f03552012-01-12 12:37:54 -080052/*
53 * Version history:
54 * V1 Beta: 0.1
55 * V1 RC < 2008/1/31: 1.0
56 * V1 RC > 2008/1/31: 2.0
57 * Win7: 4.2
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -070058 * Win8: 5.1
Keith Mange1a363102015-08-13 08:43:48 -070059 * Win8.1: 6.0
60 * Win10: 6.2
K. Y. Srinivasan09f03552012-01-12 12:37:54 -080061 */
62
Keith Mange2492fd72015-08-13 08:43:47 -070063#define VMSTOR_PROTO_VERSION(MAJOR_, MINOR_) ((((MAJOR_) & 0xff) << 8) | \
64 (((MINOR_) & 0xff)))
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -070065
Keith Mange1a363102015-08-13 08:43:48 -070066#define VMSTOR_PROTO_VERSION_WIN6 VMSTOR_PROTO_VERSION(2, 0)
Keith Mange2492fd72015-08-13 08:43:47 -070067#define VMSTOR_PROTO_VERSION_WIN7 VMSTOR_PROTO_VERSION(4, 2)
68#define VMSTOR_PROTO_VERSION_WIN8 VMSTOR_PROTO_VERSION(5, 1)
Keith Mange1a363102015-08-13 08:43:48 -070069#define VMSTOR_PROTO_VERSION_WIN8_1 VMSTOR_PROTO_VERSION(6, 0)
70#define VMSTOR_PROTO_VERSION_WIN10 VMSTOR_PROTO_VERSION(6, 2)
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -070071
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -070072/* Packet structure describing virtual storage requests. */
73enum vstor_packet_operation {
74 VSTOR_OPERATION_COMPLETE_IO = 1,
75 VSTOR_OPERATION_REMOVE_DEVICE = 2,
76 VSTOR_OPERATION_EXECUTE_SRB = 3,
77 VSTOR_OPERATION_RESET_LUN = 4,
78 VSTOR_OPERATION_RESET_ADAPTER = 5,
79 VSTOR_OPERATION_RESET_BUS = 6,
80 VSTOR_OPERATION_BEGIN_INITIALIZATION = 7,
81 VSTOR_OPERATION_END_INITIALIZATION = 8,
82 VSTOR_OPERATION_QUERY_PROTOCOL_VERSION = 9,
83 VSTOR_OPERATION_QUERY_PROPERTIES = 10,
K. Y. Srinivasan2b9525f2011-11-08 09:01:48 -080084 VSTOR_OPERATION_ENUMERATE_BUS = 11,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -070085 VSTOR_OPERATION_FCHBA_DATA = 12,
86 VSTOR_OPERATION_CREATE_SUB_CHANNELS = 13,
87 VSTOR_OPERATION_MAXIMUM = 13
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -070088};
89
90/*
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -070091 * WWN packet for Fibre Channel HBA
92 */
93
94struct hv_fc_wwn_packet {
K. Y. Srinivasan83d1e8b2015-12-23 13:15:48 -080095 u8 primary_active;
96 u8 reserved1[3];
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -070097 u8 primary_port_wwn[8];
98 u8 primary_node_wwn[8];
99 u8 secondary_port_wwn[8];
100 u8 secondary_node_wwn[8];
101};
102
103
104
105/*
106 * SRB Flag Bits
107 */
108
109#define SRB_FLAGS_QUEUE_ACTION_ENABLE 0x00000002
110#define SRB_FLAGS_DISABLE_DISCONNECT 0x00000004
111#define SRB_FLAGS_DISABLE_SYNCH_TRANSFER 0x00000008
112#define SRB_FLAGS_BYPASS_FROZEN_QUEUE 0x00000010
113#define SRB_FLAGS_DISABLE_AUTOSENSE 0x00000020
114#define SRB_FLAGS_DATA_IN 0x00000040
115#define SRB_FLAGS_DATA_OUT 0x00000080
116#define SRB_FLAGS_NO_DATA_TRANSFER 0x00000000
117#define SRB_FLAGS_UNSPECIFIED_DIRECTION (SRB_FLAGS_DATA_IN | SRB_FLAGS_DATA_OUT)
118#define SRB_FLAGS_NO_QUEUE_FREEZE 0x00000100
119#define SRB_FLAGS_ADAPTER_CACHE_ENABLE 0x00000200
120#define SRB_FLAGS_FREE_SENSE_BUFFER 0x00000400
121
122/*
123 * This flag indicates the request is part of the workflow for processing a D3.
124 */
125#define SRB_FLAGS_D3_PROCESSING 0x00000800
126#define SRB_FLAGS_IS_ACTIVE 0x00010000
127#define SRB_FLAGS_ALLOCATED_FROM_ZONE 0x00020000
128#define SRB_FLAGS_SGLIST_FROM_POOL 0x00040000
129#define SRB_FLAGS_BYPASS_LOCKED_QUEUE 0x00080000
130#define SRB_FLAGS_NO_KEEP_AWAKE 0x00100000
131#define SRB_FLAGS_PORT_DRIVER_ALLOCSENSE 0x00200000
132#define SRB_FLAGS_PORT_DRIVER_SENSEHASPORT 0x00400000
133#define SRB_FLAGS_DONT_START_NEXT_PACKET 0x00800000
134#define SRB_FLAGS_PORT_DRIVER_RESERVED 0x0F000000
135#define SRB_FLAGS_CLASS_DRIVER_RESERVED 0xF0000000
136
137
138/*
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700139 * Platform neutral description of a scsi request -
140 * this remains the same across the write regardless of 32/64 bit
141 * note: it's patterned off the SCSI_PASS_THROUGH structure
142 */
K. Y. Srinivasan6b2f9492012-01-12 12:38:05 -0800143#define STORVSC_MAX_CMD_LEN 0x10
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700144
145#define POST_WIN7_STORVSC_SENSE_BUFFER_SIZE 0x14
146#define PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE 0x12
147
148#define STORVSC_SENSE_BUFFER_SIZE 0x14
K. Y. Srinivasan6b2f9492012-01-12 12:38:05 -0800149#define STORVSC_MAX_BUF_LEN_WITH_PADDING 0x14
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700150
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700151/*
152 * Sense buffer size changed in win8; have a run-time
Keith Mangecb11fead2015-08-13 08:43:49 -0700153 * variable to track the size we should use. This value will
154 * likely change during protocol negotiation but it is valid
155 * to start by assuming pre-Win8.
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700156 */
Keith Mangecb11fead2015-08-13 08:43:49 -0700157static int sense_buffer_size = PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE;
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700158
159/*
Keith Mangecb11fead2015-08-13 08:43:49 -0700160 * The storage protocol version is determined during the
161 * initial exchange with the host. It will indicate which
162 * storage functionality is available in the host.
163*/
Keith Mange2492fd72015-08-13 08:43:47 -0700164static int vmstor_proto_version;
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700165
Long Lif8aea702015-12-04 00:07:24 -0800166#define STORVSC_LOGGING_NONE 0
167#define STORVSC_LOGGING_ERROR 1
168#define STORVSC_LOGGING_WARN 2
169
170static int logging_level = STORVSC_LOGGING_ERROR;
171module_param(logging_level, int, S_IRUGO|S_IWUSR);
172MODULE_PARM_DESC(logging_level,
173 "Logging level, 0 - None, 1 - Error (default), 2 - Warning.");
174
175static inline bool do_logging(int level)
176{
177 return logging_level >= level;
178}
179
180#define storvsc_log(dev, level, fmt, ...) \
181do { \
182 if (do_logging(level)) \
183 dev_warn(&(dev)->device, fmt, ##__VA_ARGS__); \
184} while (0)
185
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700186struct vmscsi_win8_extension {
187 /*
188 * The following were added in Windows 8
189 */
190 u16 reserve;
191 u8 queue_tag;
192 u8 queue_action;
193 u32 srb_flags;
194 u32 time_out_value;
195 u32 queue_sort_ey;
196} __packed;
197
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700198struct vmscsi_request {
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800199 u16 length;
200 u8 srb_status;
201 u8 scsi_status;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700202
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800203 u8 port_number;
204 u8 path_id;
205 u8 target_id;
206 u8 lun;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700207
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800208 u8 cdb_length;
209 u8 sense_info_length;
210 u8 data_in;
211 u8 reserved;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700212
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800213 u32 data_transfer_length;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700214
215 union {
K. Y. Srinivasan6b2f9492012-01-12 12:38:05 -0800216 u8 cdb[STORVSC_MAX_CMD_LEN];
217 u8 sense_data[STORVSC_SENSE_BUFFER_SIZE];
218 u8 reserved_array[STORVSC_MAX_BUF_LEN_WITH_PADDING];
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700219 };
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700220 /*
221 * The following was added in win8.
222 */
223 struct vmscsi_win8_extension win8_extension;
224
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700225} __attribute((packed));
226
227
228/*
Keith Mangecb11fead2015-08-13 08:43:49 -0700229 * The size of the vmscsi_request has changed in win8. The
230 * additional size is because of new elements added to the
231 * structure. These elements are valid only when we are talking
232 * to a win8 host.
233 * Track the correction to size we need to apply. This value
234 * will likely change during protocol negotiation but it is
235 * valid to start by assuming pre-Win8.
236 */
237static int vmscsi_size_delta = sizeof(struct vmscsi_win8_extension);
238
239/*
Keith Mange1a363102015-08-13 08:43:48 -0700240 * The list of storage protocols in order of preference.
241 */
242struct vmstor_protocol {
243 int protocol_version;
244 int sense_buffer_size;
245 int vmscsi_size_delta;
246};
247
248
249static const struct vmstor_protocol vmstor_protocols[] = {
250 {
251 VMSTOR_PROTO_VERSION_WIN10,
252 POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
253 0
254 },
255 {
256 VMSTOR_PROTO_VERSION_WIN8_1,
257 POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
258 0
259 },
260 {
261 VMSTOR_PROTO_VERSION_WIN8,
262 POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
263 0
264 },
265 {
266 VMSTOR_PROTO_VERSION_WIN7,
267 PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE,
268 sizeof(struct vmscsi_win8_extension),
269 },
270 {
271 VMSTOR_PROTO_VERSION_WIN6,
272 PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE,
273 sizeof(struct vmscsi_win8_extension),
274 }
275};
276
277
278/*
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700279 * This structure is sent during the intialization phase to get the different
280 * properties of the channel.
281 */
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700282
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700283#define STORAGE_CHANNEL_SUPPORTS_MULTI_CHANNEL 0x1
284
285struct vmstorage_channel_properties {
286 u32 reserved;
287 u16 max_channel_cnt;
288 u16 reserved1;
289
290 u32 flags;
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800291 u32 max_transfer_bytes;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700292
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700293 u64 reserved2;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700294} __packed;
295
296/* This structure is sent during the storage protocol negotiations. */
297struct vmstorage_protocol_version {
298 /* Major (MSW) and minor (LSW) version numbers. */
K. Y. Srinivasan85904a52012-01-12 12:38:04 -0800299 u16 major_minor;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700300
301 /*
302 * Revision number is auto-incremented whenever this file is changed
303 * (See FILL_VMSTOR_REVISION macro above). Mismatch does not
304 * definitely indicate incompatibility--but it does indicate mismatched
305 * builds.
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800306 * This is only used on the windows side. Just set it to 0.
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700307 */
K. Y. Srinivasan85904a52012-01-12 12:38:04 -0800308 u16 revision;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700309} __packed;
310
311/* Channel Property Flags */
312#define STORAGE_CHANNEL_REMOVABLE_FLAG 0x1
313#define STORAGE_CHANNEL_EMULATED_IDE_FLAG 0x2
314
315struct vstor_packet {
316 /* Requested operation type */
317 enum vstor_packet_operation operation;
318
319 /* Flags - see below for values */
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800320 u32 flags;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700321
322 /* Status of the request returned from the server side. */
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800323 u32 status;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700324
325 /* Data payload area */
326 union {
327 /*
328 * Structure used to forward SCSI commands from the
329 * client to the server.
330 */
331 struct vmscsi_request vm_srb;
332
333 /* Structure used to query channel properties. */
334 struct vmstorage_channel_properties storage_channel_properties;
335
336 /* Used during version negotiations. */
337 struct vmstorage_protocol_version version;
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700338
339 /* Fibre channel address packet */
340 struct hv_fc_wwn_packet wwn_packet;
341
342 /* Number of sub-channels to create */
343 u16 sub_channel_count;
344
345 /* This will be the maximum of the union members */
346 u8 buffer[0x34];
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700347 };
348} __packed;
349
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700350/*
K. Y. Srinivasan09f03552012-01-12 12:37:54 -0800351 * Packet Flags:
352 *
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700353 * This flag indicates that the server should send back a completion for this
354 * packet.
355 */
K. Y. Srinivasan09f03552012-01-12 12:37:54 -0800356
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700357#define REQUEST_COMPLETION_FLAG 0x1
358
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700359/* Matches Windows-end */
360enum storvsc_request_type {
K. Y. Srinivasanc6491142012-01-12 12:38:03 -0800361 WRITE_TYPE = 0,
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700362 READ_TYPE,
363 UNKNOWN_TYPE,
364};
365
K. Y. Srinivasan16046322012-01-12 12:37:57 -0800366/*
367 * SRB status codes and masks; a subset of the codes used here.
368 */
369
370#define SRB_STATUS_AUTOSENSE_VALID 0x80
K. Y. Srinivasan3209f9d2015-10-06 18:04:01 -0700371#define SRB_STATUS_QUEUE_FROZEN 0x40
K. Y. Srinivasan16046322012-01-12 12:37:57 -0800372#define SRB_STATUS_INVALID_LUN 0x20
373#define SRB_STATUS_SUCCESS 0x01
K. Y. Srinivasan67812092013-02-21 12:04:53 -0800374#define SRB_STATUS_ABORTED 0x02
K. Y. Srinivasan16046322012-01-12 12:37:57 -0800375#define SRB_STATUS_ERROR 0x04
376
K. Y. Srinivasan3209f9d2015-10-06 18:04:01 -0700377#define SRB_STATUS(status) \
378 (status & ~(SRB_STATUS_AUTOSENSE_VALID | SRB_STATUS_QUEUE_FROZEN))
K. Y. Srinivasanaf9584b2012-01-12 12:38:08 -0800379/*
380 * This is the end of Protocol specific defines.
381 */
382
K. Y. Srinivasanb9ec3a52015-03-27 00:27:14 -0700383static int storvsc_ringbuffer_size = (256 * PAGE_SIZE);
K. Y. Srinivasanf458aad2015-03-27 00:27:15 -0700384static u32 max_outstanding_req_per_channel;
385
386static int storvsc_vcpus_per_sub_channel = 4;
K. Y. Srinivasanaf9584b2012-01-12 12:38:08 -0800387
388module_param(storvsc_ringbuffer_size, int, S_IRUGO);
389MODULE_PARM_DESC(storvsc_ringbuffer_size, "Ring buffer size (bytes)");
390
K. Y. Srinivasanf458aad2015-03-27 00:27:15 -0700391module_param(storvsc_vcpus_per_sub_channel, int, S_IRUGO);
392MODULE_PARM_DESC(vcpus_per_sub_channel, "Ratio of VCPUs to subchannels");
K. Y. Srinivasan893def32013-06-04 12:05:05 -0700393/*
394 * Timeout in seconds for all devices managed by this driver.
395 */
396static int storvsc_timeout = 180;
397
K. Y. Srinivasanf3cfabc2014-07-21 16:06:01 -0700398static int msft_blist_flags = BLIST_TRY_VPD_PAGES;
399
K. Y. Srinivasanaf9584b2012-01-12 12:38:08 -0800400
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700401static void storvsc_on_channel_callback(void *context);
402
K. Y. Srinivasan4cd83ec2014-07-12 09:48:26 -0700403#define STORVSC_MAX_LUNS_PER_TARGET 255
404#define STORVSC_MAX_TARGETS 2
405#define STORVSC_MAX_CHANNELS 8
K. Y. Srinivasanaf9584b2012-01-12 12:38:08 -0800406
K. Y. Srinivasan4cd83ec2014-07-12 09:48:26 -0700407#define STORVSC_FC_MAX_LUNS_PER_TARGET 255
408#define STORVSC_FC_MAX_TARGETS 128
409#define STORVSC_FC_MAX_CHANNELS 8
K. Y. Srinivasanaf9584b2012-01-12 12:38:08 -0800410
K. Y. Srinivasan4cd83ec2014-07-12 09:48:26 -0700411#define STORVSC_IDE_MAX_LUNS_PER_TARGET 64
412#define STORVSC_IDE_MAX_TARGETS 1
413#define STORVSC_IDE_MAX_CHANNELS 1
K. Y. Srinivasan16046322012-01-12 12:37:57 -0800414
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800415struct storvsc_cmd_request {
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800416 struct scsi_cmnd *cmd;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700417
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700418 struct hv_device *device;
419
420 /* Synchronize the request/response if needed */
421 struct completion wait_event;
422
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -0700423 struct vmbus_channel_packet_multipage_buffer mpb;
424 struct vmbus_packet_mpb_array *payload;
425 u32 payload_sz;
426
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700427 struct vstor_packet vstor_packet;
428};
429
430
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700431/* A storvsc device is a device object that contains a vmbus channel */
432struct storvsc_device {
433 struct hv_device *device;
434
435 bool destroy;
436 bool drain_notify;
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700437 bool open_sub_channel;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700438 atomic_t num_outstanding_req;
K. Y. Srinivasancd654ea2011-09-13 10:59:48 -0700439 struct Scsi_Host *host;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700440
441 wait_queue_head_t waiting_to_drain;
442
443 /*
444 * Each unique Port/Path/Target represents 1 channel ie scsi
445 * controller. In reality, the pathid, targetid is always 0
446 * and the port is set by us
447 */
448 unsigned int port_number;
449 unsigned char path_id;
450 unsigned char target_id;
451
K. Y. Srinivasan5117b932015-03-27 00:27:17 -0700452 /*
453 * Max I/O, the device can support.
454 */
455 u32 max_transfer_bytes;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700456 /* Used for vsc/vsp channel reset process */
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800457 struct storvsc_cmd_request init_request;
458 struct storvsc_cmd_request reset_request;
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700459};
460
K. Y. Srinivasance3e3012011-12-01 04:59:20 -0800461struct hv_host_device {
462 struct hv_device *dev;
K. Y. Srinivasanc1b3d062011-08-27 11:31:25 -0700463 unsigned int port;
464 unsigned char path;
465 unsigned char target;
466};
467
K. Y. Srinivasan12675792011-11-08 09:01:49 -0800468struct storvsc_scan_work {
469 struct work_struct work;
470 struct Scsi_Host *host;
471 uint lun;
472};
473
K. Y. Srinivasan67812092013-02-21 12:04:53 -0800474static void storvsc_device_scan(struct work_struct *work)
475{
476 struct storvsc_scan_work *wrk;
477 uint lun;
478 struct scsi_device *sdev;
479
480 wrk = container_of(work, struct storvsc_scan_work, work);
481 lun = wrk->lun;
482
483 sdev = scsi_device_lookup(wrk->host, 0, 0, lun);
484 if (!sdev)
485 goto done;
486 scsi_rescan_device(&sdev->sdev_gendev);
487 scsi_device_put(sdev);
488
489done:
490 kfree(wrk);
491}
492
K. Y. Srinivasan2a09ed32014-12-16 13:21:42 -0800493static void storvsc_host_scan(struct work_struct *work)
K. Y. Srinivasan12675792011-11-08 09:01:49 -0800494{
495 struct storvsc_scan_work *wrk;
K. Y. Srinivasan2a09ed32014-12-16 13:21:42 -0800496 struct Scsi_Host *host;
K. Y. Srinivasan34a716b2014-12-16 13:21:43 -0800497 struct scsi_device *sdev;
K. Y. Srinivasan12675792011-11-08 09:01:49 -0800498
499 wrk = container_of(work, struct storvsc_scan_work, work);
K. Y. Srinivasan2a09ed32014-12-16 13:21:42 -0800500 host = wrk->host;
K. Y. Srinivasan12675792011-11-08 09:01:49 -0800501
K. Y. Srinivasan34a716b2014-12-16 13:21:43 -0800502 /*
503 * Before scanning the host, first check to see if any of the
504 * currrently known devices have been hot removed. We issue a
505 * "unit ready" command against all currently known devices.
506 * This I/O will result in an error for devices that have been
507 * removed. As part of handling the I/O error, we remove the device.
508 *
509 * When a LUN is added or removed, the host sends us a signal to
510 * scan the host. Thus we are forced to discover the LUNs that
511 * may have been removed this way.
512 */
513 mutex_lock(&host->scan_mutex);
Vitaly Kuznetsov8d6a9f52015-07-01 11:31:27 +0200514 shost_for_each_device(sdev, host)
K. Y. Srinivasan34a716b2014-12-16 13:21:43 -0800515 scsi_test_unit_ready(sdev, 1, 1, NULL);
K. Y. Srinivasan34a716b2014-12-16 13:21:43 -0800516 mutex_unlock(&host->scan_mutex);
517 /*
518 * Now scan the host to discover LUNs that may have been added.
519 */
K. Y. Srinivasan2a09ed32014-12-16 13:21:42 -0800520 scsi_scan_host(host);
521
K. Y. Srinivasan12675792011-11-08 09:01:49 -0800522 kfree(wrk);
523}
524
K. Y. Srinivasanb4017312011-11-08 09:01:50 -0800525static void storvsc_remove_lun(struct work_struct *work)
526{
527 struct storvsc_scan_work *wrk;
528 struct scsi_device *sdev;
529
530 wrk = container_of(work, struct storvsc_scan_work, work);
531 if (!scsi_host_get(wrk->host))
532 goto done;
533
534 sdev = scsi_device_lookup(wrk->host, 0, 0, wrk->lun);
535
536 if (sdev) {
537 scsi_remove_device(sdev);
538 scsi_device_put(sdev);
539 }
540 scsi_host_put(wrk->host);
541
542done:
543 kfree(wrk);
544}
545
K. Y. Srinivasanaf9584b2012-01-12 12:38:08 -0800546
547/*
K. Y. Srinivasana8c18c52012-01-12 12:38:00 -0800548 * We can get incoming messages from the host that are not in response to
549 * messages that we have sent out. An example of this would be messages
550 * received by the guest to notify dynamic addition/removal of LUNs. To
551 * deal with potential race conditions where the driver may be in the
552 * midst of being unloaded when we might receive an unsolicited message
553 * from the host, we have implemented a mechanism to gurantee sequential
554 * consistency:
555 *
556 * 1) Once the device is marked as being destroyed, we will fail all
557 * outgoing messages.
558 * 2) We permit incoming messages when the device is being destroyed,
559 * only to properly account for messages already sent out.
560 */
561
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700562static inline struct storvsc_device *get_out_stor_device(
563 struct hv_device *device)
564{
565 struct storvsc_device *stor_device;
566
K. Y. Srinivasancd654ea2011-09-13 10:59:48 -0700567 stor_device = hv_get_drvdata(device);
K. Y. Srinivasanf0d79fe2011-08-27 11:31:24 -0700568
569 if (stor_device && stor_device->destroy)
570 stor_device = NULL;
571
572 return stor_device;
573}
574
575
576static inline void storvsc_wait_to_drain(struct storvsc_device *dev)
577{
578 dev->drain_notify = true;
579 wait_event(dev->waiting_to_drain,
580 atomic_read(&dev->num_outstanding_req) == 0);
581 dev->drain_notify = false;
582}
Hank Janssenbef4a342009-07-13 16:01:31 -0700583
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700584static inline struct storvsc_device *get_in_stor_device(
585 struct hv_device *device)
586{
587 struct storvsc_device *stor_device;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700588
K. Y. Srinivasancd654ea2011-09-13 10:59:48 -0700589 stor_device = hv_get_drvdata(device);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700590
591 if (!stor_device)
592 goto get_in_err;
593
594 /*
595 * If the device is being destroyed; allow incoming
596 * traffic only to cleanup outstanding requests.
597 */
598
599 if (stor_device->destroy &&
600 (atomic_read(&stor_device->num_outstanding_req) == 0))
601 stor_device = NULL;
602
603get_in_err:
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700604 return stor_device;
605
606}
607
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700608static void handle_sc_creation(struct vmbus_channel *new_sc)
609{
610 struct hv_device *device = new_sc->primary_channel->device_obj;
611 struct storvsc_device *stor_device;
612 struct vmstorage_channel_properties props;
613
614 stor_device = get_out_stor_device(device);
615 if (!stor_device)
616 return;
617
618 if (stor_device->open_sub_channel == false)
619 return;
620
621 memset(&props, 0, sizeof(struct vmstorage_channel_properties));
622
623 vmbus_open(new_sc,
624 storvsc_ringbuffer_size,
625 storvsc_ringbuffer_size,
626 (void *)&props,
627 sizeof(struct vmstorage_channel_properties),
628 storvsc_on_channel_callback, new_sc);
629}
630
631static void handle_multichannel_storage(struct hv_device *device, int max_chns)
632{
633 struct storvsc_device *stor_device;
634 int num_cpus = num_online_cpus();
635 int num_sc;
636 struct storvsc_cmd_request *request;
637 struct vstor_packet *vstor_packet;
638 int ret, t;
639
640 num_sc = ((max_chns > num_cpus) ? num_cpus : max_chns);
641 stor_device = get_out_stor_device(device);
642 if (!stor_device)
643 return;
644
645 request = &stor_device->init_request;
646 vstor_packet = &request->vstor_packet;
647
648 stor_device->open_sub_channel = true;
649 /*
650 * Establish a handler for dealing with subchannels.
651 */
652 vmbus_set_sc_create_callback(device->channel, handle_sc_creation);
653
654 /*
655 * Check to see if sub-channels have already been created. This
656 * can happen when this driver is re-loaded after unloading.
657 */
658
659 if (vmbus_are_subchannels_present(device->channel))
660 return;
661
662 stor_device->open_sub_channel = false;
663 /*
664 * Request the host to create sub-channels.
665 */
666 memset(request, 0, sizeof(struct storvsc_cmd_request));
667 init_completion(&request->wait_event);
668 vstor_packet->operation = VSTOR_OPERATION_CREATE_SUB_CHANNELS;
669 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
670 vstor_packet->sub_channel_count = num_sc;
671
672 ret = vmbus_sendpacket(device->channel, vstor_packet,
673 (sizeof(struct vstor_packet) -
674 vmscsi_size_delta),
675 (unsigned long)request,
676 VM_PKT_DATA_INBAND,
677 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
678
679 if (ret != 0)
680 return;
681
682 t = wait_for_completion_timeout(&request->wait_event, 10*HZ);
683 if (t == 0)
684 return;
685
686 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
687 vstor_packet->status != 0)
688 return;
689
690 /*
691 * Now that we created the sub-channels, invoke the check; this
692 * may trigger the callback.
693 */
694 stor_device->open_sub_channel = true;
695 vmbus_are_subchannels_present(device->channel);
696}
697
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700698static int storvsc_channel_init(struct hv_device *device)
699{
700 struct storvsc_device *stor_device;
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800701 struct storvsc_cmd_request *request;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700702 struct vstor_packet *vstor_packet;
Keith Mange1a363102015-08-13 08:43:48 -0700703 int ret, t, i;
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700704 int max_chns;
705 bool process_sub_channels = false;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700706
707 stor_device = get_out_stor_device(device);
708 if (!stor_device)
709 return -ENODEV;
710
711 request = &stor_device->init_request;
712 vstor_packet = &request->vstor_packet;
713
714 /*
715 * Now, initiate the vsc/vsp initialization protocol on the open
716 * channel
717 */
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800718 memset(request, 0, sizeof(struct storvsc_cmd_request));
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700719 init_completion(&request->wait_event);
720 vstor_packet->operation = VSTOR_OPERATION_BEGIN_INITIALIZATION;
721 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
722
723 ret = vmbus_sendpacket(device->channel, vstor_packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700724 (sizeof(struct vstor_packet) -
725 vmscsi_size_delta),
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700726 (unsigned long)request,
727 VM_PKT_DATA_INBAND,
728 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
729 if (ret != 0)
730 goto cleanup;
731
732 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
733 if (t == 0) {
734 ret = -ETIMEDOUT;
735 goto cleanup;
736 }
737
738 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
K. Y. Srinivasan111f2d12015-08-13 08:43:52 -0700739 vstor_packet->status != 0) {
740 ret = -EINVAL;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700741 goto cleanup;
K. Y. Srinivasan111f2d12015-08-13 08:43:52 -0700742 }
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700743
744
Keith Mange1a363102015-08-13 08:43:48 -0700745 for (i = 0; i < ARRAY_SIZE(vmstor_protocols); i++) {
746 /* reuse the packet for version range supported */
747 memset(vstor_packet, 0, sizeof(struct vstor_packet));
748 vstor_packet->operation =
749 VSTOR_OPERATION_QUERY_PROTOCOL_VERSION;
750 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700751
Keith Mange1a363102015-08-13 08:43:48 -0700752 vstor_packet->version.major_minor =
753 vmstor_protocols[i].protocol_version;
K. Y. Srinivasan85904a52012-01-12 12:38:04 -0800754
Keith Mange1a363102015-08-13 08:43:48 -0700755 /*
756 * The revision number is only used in Windows; set it to 0.
757 */
758 vstor_packet->version.revision = 0;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700759
Keith Mange1a363102015-08-13 08:43:48 -0700760 ret = vmbus_sendpacket(device->channel, vstor_packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700761 (sizeof(struct vstor_packet) -
762 vmscsi_size_delta),
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700763 (unsigned long)request,
764 VM_PKT_DATA_INBAND,
765 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
Keith Mange1a363102015-08-13 08:43:48 -0700766 if (ret != 0)
767 goto cleanup;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700768
Keith Mange1a363102015-08-13 08:43:48 -0700769 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
770 if (t == 0) {
771 ret = -ETIMEDOUT;
772 goto cleanup;
773 }
774
775 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO) {
776 ret = -EINVAL;
777 goto cleanup;
778 }
779
780 if (vstor_packet->status == 0) {
781 vmstor_proto_version =
782 vmstor_protocols[i].protocol_version;
783
784 sense_buffer_size =
785 vmstor_protocols[i].sense_buffer_size;
786
787 vmscsi_size_delta =
788 vmstor_protocols[i].vmscsi_size_delta;
789
790 break;
791 }
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700792 }
793
Keith Mange1a363102015-08-13 08:43:48 -0700794 if (vstor_packet->status != 0) {
795 ret = -EINVAL;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700796 goto cleanup;
Keith Mange1a363102015-08-13 08:43:48 -0700797 }
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700798
799
800 memset(vstor_packet, 0, sizeof(struct vstor_packet));
801 vstor_packet->operation = VSTOR_OPERATION_QUERY_PROPERTIES;
802 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700803
804 ret = vmbus_sendpacket(device->channel, vstor_packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700805 (sizeof(struct vstor_packet) -
806 vmscsi_size_delta),
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700807 (unsigned long)request,
808 VM_PKT_DATA_INBAND,
809 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
810
811 if (ret != 0)
812 goto cleanup;
813
814 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
815 if (t == 0) {
816 ret = -ETIMEDOUT;
817 goto cleanup;
818 }
819
820 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
K. Y. Srinivasan111f2d12015-08-13 08:43:52 -0700821 vstor_packet->status != 0) {
822 ret = -EINVAL;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700823 goto cleanup;
K. Y. Srinivasan111f2d12015-08-13 08:43:52 -0700824 }
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700825
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700826 /*
827 * Check to see if multi-channel support is there.
828 * Hosts that implement protocol version of 5.1 and above
829 * support multi-channel.
830 */
831 max_chns = vstor_packet->storage_channel_properties.max_channel_cnt;
Keith Mangee6c4bc62015-08-13 08:43:50 -0700832 if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN8) {
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700833 if (vstor_packet->storage_channel_properties.flags &
834 STORAGE_CHANNEL_SUPPORTS_MULTI_CHANNEL)
835 process_sub_channels = true;
836 }
K. Y. Srinivasan5117b932015-03-27 00:27:17 -0700837 stor_device->max_transfer_bytes =
838 vstor_packet->storage_channel_properties.max_transfer_bytes;
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700839
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700840 memset(vstor_packet, 0, sizeof(struct vstor_packet));
841 vstor_packet->operation = VSTOR_OPERATION_END_INITIALIZATION;
842 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
843
844 ret = vmbus_sendpacket(device->channel, vstor_packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -0700845 (sizeof(struct vstor_packet) -
846 vmscsi_size_delta),
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700847 (unsigned long)request,
848 VM_PKT_DATA_INBAND,
849 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
850
851 if (ret != 0)
852 goto cleanup;
853
854 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
855 if (t == 0) {
856 ret = -ETIMEDOUT;
857 goto cleanup;
858 }
859
860 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
K. Y. Srinivasan111f2d12015-08-13 08:43:52 -0700861 vstor_packet->status != 0) {
862 ret = -EINVAL;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700863 goto cleanup;
K. Y. Srinivasan111f2d12015-08-13 08:43:52 -0700864 }
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700865
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -0700866 if (process_sub_channels)
867 handle_multichannel_storage(device, max_chns);
868
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700869
870cleanup:
871 return ret;
872}
873
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800874static void storvsc_handle_error(struct vmscsi_request *vm_srb,
875 struct scsi_cmnd *scmnd,
876 struct Scsi_Host *host,
877 u8 asc, u8 ascq)
878{
879 struct storvsc_scan_work *wrk;
880 void (*process_err_fn)(struct work_struct *work);
881 bool do_work = false;
882
K. Y. Srinivasan3209f9d2015-10-06 18:04:01 -0700883 switch (SRB_STATUS(vm_srb->srb_status)) {
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800884 case SRB_STATUS_ERROR:
885 /*
886 * If there is an error; offline the device since all
887 * error recovery strategies would have already been
888 * deployed on the host side. However, if the command
889 * were a pass-through command deal with it appropriately.
890 */
891 switch (scmnd->cmnd[0]) {
892 case ATA_16:
893 case ATA_12:
894 set_host_byte(scmnd, DID_PASSTHROUGH);
895 break;
K. Y. Srinivasan3533f8602014-07-12 09:48:32 -0700896 /*
897 * On Some Windows hosts TEST_UNIT_READY command can return
898 * SRB_STATUS_ERROR, let the upper level code deal with it
899 * based on the sense information.
900 */
901 case TEST_UNIT_READY:
902 break;
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800903 default:
904 set_host_byte(scmnd, DID_TARGET_FAILURE);
905 }
906 break;
907 case SRB_STATUS_INVALID_LUN:
908 do_work = true;
909 process_err_fn = storvsc_remove_lun;
910 break;
K. Y. Srinivasan67812092013-02-21 12:04:53 -0800911 case (SRB_STATUS_ABORTED | SRB_STATUS_AUTOSENSE_VALID):
912 if ((asc == 0x2a) && (ascq == 0x9)) {
913 do_work = true;
914 process_err_fn = storvsc_device_scan;
915 /*
916 * Retry the I/O that trigerred this.
917 */
918 set_host_byte(scmnd, DID_REQUEUE);
919 }
920 break;
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800921 }
K. Y. Srinivasan67812092013-02-21 12:04:53 -0800922
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800923 if (!do_work)
924 return;
925
926 /*
927 * We need to schedule work to process this error; schedule it.
928 */
929 wrk = kmalloc(sizeof(struct storvsc_scan_work), GFP_ATOMIC);
930 if (!wrk) {
931 set_host_byte(scmnd, DID_TARGET_FAILURE);
932 return;
933 }
934
935 wrk->host = host;
936 wrk->lun = vm_srb->lun;
937 INIT_WORK(&wrk->work, process_err_fn);
938 schedule_work(&wrk->work);
939}
940
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800941
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800942static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request)
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800943{
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800944 struct scsi_cmnd *scmnd = cmd_request->cmd;
945 struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800946 struct scsi_sense_hdr sense_hdr;
947 struct vmscsi_request *vm_srb;
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800948 struct Scsi_Host *host;
949 struct storvsc_device *stor_dev;
950 struct hv_device *dev = host_dev->dev;
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -0700951 u32 payload_sz = cmd_request->payload_sz;
952 void *payload = cmd_request->payload;
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800953
954 stor_dev = get_in_stor_device(dev);
955 host = stor_dev->host;
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800956
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800957 vm_srb = &cmd_request->vstor_packet.vm_srb;
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800958
K. Y. Srinivasan42e22ca2012-04-05 12:26:52 -0700959 scmnd->result = vm_srb->scsi_status;
960
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800961 if (scmnd->result) {
962 if (scsi_normalize_sense(scmnd->sense_buffer,
Long Lif8aea702015-12-04 00:07:24 -0800963 SCSI_SENSE_BUFFERSIZE, &sense_hdr) &&
964 do_logging(STORVSC_LOGGING_ERROR))
Hannes Reinecked811b842014-10-24 14:26:45 +0200965 scsi_print_sense_hdr(scmnd->device, "storvsc",
966 &sense_hdr);
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800967 }
968
K. Y. Srinivasanc50bd442013-02-21 12:04:52 -0800969 if (vm_srb->srb_status != SRB_STATUS_SUCCESS)
970 storvsc_handle_error(vm_srb, scmnd, host, sense_hdr.asc,
971 sense_hdr.ascq);
972
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800973 scsi_set_resid(scmnd,
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -0700974 cmd_request->payload->range.len -
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800975 vm_srb->data_transfer_length);
976
Christoph Hellwigead37002014-12-29 20:05:09 -0800977 scmnd->scsi_done(scmnd);
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -0700978
979 if (payload_sz >
980 sizeof(struct vmbus_channel_packet_multipage_buffer))
981 kfree(payload);
K. Y. Srinivasan27073882012-01-12 12:38:01 -0800982}
983
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700984static void storvsc_on_io_completion(struct hv_device *device,
985 struct vstor_packet *vstor_packet,
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -0800986 struct storvsc_cmd_request *request)
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700987{
988 struct storvsc_device *stor_device;
989 struct vstor_packet *stor_pkt;
990
K. Y. Srinivasancd654ea2011-09-13 10:59:48 -0700991 stor_device = hv_get_drvdata(device);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -0700992 stor_pkt = &request->vstor_packet;
993
K. Y. Srinivasan4ed51a22011-08-27 11:31:26 -0700994 /*
995 * The current SCSI handling on the host side does
996 * not correctly handle:
997 * INQUIRY command with page code parameter set to 0x80
998 * MODE_SENSE command with cmd[2] == 0x1c
999 *
1000 * Setup srb and scsi status so this won't be fatal.
1001 * We do this so we can distinguish truly fatal failues
1002 * (srb status == 0x4) and off-line the device in that case.
1003 */
1004
1005 if ((stor_pkt->vm_srb.cdb[0] == INQUIRY) ||
K. Y. Srinivasana8c18c52012-01-12 12:38:00 -08001006 (stor_pkt->vm_srb.cdb[0] == MODE_SENSE)) {
K. Y. Srinivasan4ed51a22011-08-27 11:31:26 -07001007 vstor_packet->vm_srb.scsi_status = 0;
K. Y. Srinivasan16046322012-01-12 12:37:57 -08001008 vstor_packet->vm_srb.srb_status = SRB_STATUS_SUCCESS;
K. Y. Srinivasan4ed51a22011-08-27 11:31:26 -07001009 }
1010
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001011
1012 /* Copy over the status...etc */
1013 stor_pkt->vm_srb.scsi_status = vstor_packet->vm_srb.scsi_status;
1014 stor_pkt->vm_srb.srb_status = vstor_packet->vm_srb.srb_status;
1015 stor_pkt->vm_srb.sense_info_length =
1016 vstor_packet->vm_srb.sense_info_length;
1017
Long Lif8aea702015-12-04 00:07:24 -08001018 if (vstor_packet->vm_srb.scsi_status != 0 ||
1019 vstor_packet->vm_srb.srb_status != SRB_STATUS_SUCCESS)
1020 storvsc_log(device, STORVSC_LOGGING_WARN,
1021 "cmd 0x%x scsi status 0x%x srb status 0x%x\n",
1022 stor_pkt->vm_srb.cdb[0],
1023 vstor_packet->vm_srb.scsi_status,
1024 vstor_packet->vm_srb.srb_status);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001025
1026 if ((vstor_packet->vm_srb.scsi_status & 0xFF) == 0x02) {
1027 /* CHECK_CONDITION */
K. Y. Srinivasan16046322012-01-12 12:37:57 -08001028 if (vstor_packet->vm_srb.srb_status &
1029 SRB_STATUS_AUTOSENSE_VALID) {
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001030 /* autosense data available */
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001031
Long Lif8aea702015-12-04 00:07:24 -08001032 storvsc_log(device, STORVSC_LOGGING_WARN,
1033 "stor pkt %p autosense data valid - len %d\n",
1034 request, vstor_packet->vm_srb.sense_info_length);
1035
Christoph Hellwigead37002014-12-29 20:05:09 -08001036 memcpy(request->cmd->sense_buffer,
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001037 vstor_packet->vm_srb.sense_data,
1038 vstor_packet->vm_srb.sense_info_length);
1039
1040 }
1041 }
1042
1043 stor_pkt->vm_srb.data_transfer_length =
1044 vstor_packet->vm_srb.data_transfer_length;
1045
K. Y. Srinivasan27073882012-01-12 12:38:01 -08001046 storvsc_command_completion(request);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001047
1048 if (atomic_dec_and_test(&stor_device->num_outstanding_req) &&
1049 stor_device->drain_notify)
1050 wake_up(&stor_device->waiting_to_drain);
1051
1052
1053}
1054
1055static void storvsc_on_receive(struct hv_device *device,
1056 struct vstor_packet *vstor_packet,
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -08001057 struct storvsc_cmd_request *request)
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001058{
K. Y. Srinivasan12675792011-11-08 09:01:49 -08001059 struct storvsc_scan_work *work;
1060 struct storvsc_device *stor_device;
1061
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001062 switch (vstor_packet->operation) {
1063 case VSTOR_OPERATION_COMPLETE_IO:
1064 storvsc_on_io_completion(device, vstor_packet, request);
1065 break;
K. Y. Srinivasan12675792011-11-08 09:01:49 -08001066
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001067 case VSTOR_OPERATION_REMOVE_DEVICE:
K. Y. Srinivasan12675792011-11-08 09:01:49 -08001068 case VSTOR_OPERATION_ENUMERATE_BUS:
1069 stor_device = get_in_stor_device(device);
1070 work = kmalloc(sizeof(struct storvsc_scan_work), GFP_ATOMIC);
1071 if (!work)
1072 return;
1073
K. Y. Srinivasan2a09ed32014-12-16 13:21:42 -08001074 INIT_WORK(&work->work, storvsc_host_scan);
K. Y. Srinivasan12675792011-11-08 09:01:49 -08001075 work->host = stor_device->host;
1076 schedule_work(&work->work);
1077 break;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001078
1079 default:
1080 break;
1081 }
1082}
1083
1084static void storvsc_on_channel_callback(void *context)
1085{
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -07001086 struct vmbus_channel *channel = (struct vmbus_channel *)context;
1087 struct hv_device *device;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001088 struct storvsc_device *stor_device;
1089 u32 bytes_recvd;
1090 u64 request_id;
1091 unsigned char packet[ALIGN(sizeof(struct vstor_packet), 8)];
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -08001092 struct storvsc_cmd_request *request;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001093 int ret;
1094
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -07001095 if (channel->primary_channel != NULL)
1096 device = channel->primary_channel->device_obj;
1097 else
1098 device = channel->device_obj;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001099
1100 stor_device = get_in_stor_device(device);
1101 if (!stor_device)
1102 return;
1103
1104 do {
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -07001105 ret = vmbus_recvpacket(channel, packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001106 ALIGN((sizeof(struct vstor_packet) -
1107 vmscsi_size_delta), 8),
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001108 &bytes_recvd, &request_id);
1109 if (ret == 0 && bytes_recvd > 0) {
1110
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -08001111 request = (struct storvsc_cmd_request *)
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001112 (unsigned long)request_id;
1113
1114 if ((request == &stor_device->init_request) ||
1115 (request == &stor_device->reset_request)) {
1116
1117 memcpy(&request->vstor_packet, packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001118 (sizeof(struct vstor_packet) -
1119 vmscsi_size_delta));
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001120 complete(&request->wait_event);
1121 } else {
1122 storvsc_on_receive(device,
1123 (struct vstor_packet *)packet,
1124 request);
1125 }
1126 } else {
1127 break;
1128 }
1129 } while (1);
1130
1131 return;
1132}
1133
1134static int storvsc_connect_to_vsp(struct hv_device *device, u32 ring_size)
1135{
1136 struct vmstorage_channel_properties props;
1137 int ret;
1138
1139 memset(&props, 0, sizeof(struct vmstorage_channel_properties));
1140
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001141 ret = vmbus_open(device->channel,
1142 ring_size,
1143 ring_size,
1144 (void *)&props,
1145 sizeof(struct vmstorage_channel_properties),
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -07001146 storvsc_on_channel_callback, device->channel);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001147
1148 if (ret != 0)
1149 return ret;
1150
1151 ret = storvsc_channel_init(device);
1152
1153 return ret;
1154}
1155
K. Y. Srinivasanc1b3d062011-08-27 11:31:25 -07001156static int storvsc_dev_remove(struct hv_device *device)
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001157{
1158 struct storvsc_device *stor_device;
1159 unsigned long flags;
1160
K. Y. Srinivasancd654ea2011-09-13 10:59:48 -07001161 stor_device = hv_get_drvdata(device);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001162
1163 spin_lock_irqsave(&device->channel->inbound_lock, flags);
1164 stor_device->destroy = true;
1165 spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
1166
1167 /*
1168 * At this point, all outbound traffic should be disable. We
1169 * only allow inbound traffic (responses) to proceed so that
1170 * outstanding requests can be completed.
1171 */
1172
1173 storvsc_wait_to_drain(stor_device);
1174
1175 /*
1176 * Since we have already drained, we don't need to busy wait
1177 * as was done in final_release_stor_device()
1178 * Note that we cannot set the ext pointer to NULL until
1179 * we have drained - to drain the outgoing packets, we need to
1180 * allow incoming packets.
1181 */
1182 spin_lock_irqsave(&device->channel->inbound_lock, flags);
K. Y. Srinivasancd654ea2011-09-13 10:59:48 -07001183 hv_set_drvdata(device, NULL);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001184 spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
1185
1186 /* Close the channel */
1187 vmbus_close(device->channel);
1188
1189 kfree(stor_device);
1190 return 0;
1191}
1192
K. Y. Srinivasanc1b3d062011-08-27 11:31:25 -07001193static int storvsc_do_io(struct hv_device *device,
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001194 struct storvsc_cmd_request *request)
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001195{
1196 struct storvsc_device *stor_device;
1197 struct vstor_packet *vstor_packet;
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -07001198 struct vmbus_channel *outgoing_channel;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001199 int ret = 0;
1200
1201 vstor_packet = &request->vstor_packet;
1202 stor_device = get_out_stor_device(device);
1203
1204 if (!stor_device)
1205 return -ENODEV;
1206
1207
1208 request->device = device;
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -07001209 /*
1210 * Select an an appropriate channel to send the request out.
1211 */
1212
1213 outgoing_channel = vmbus_get_outgoing_channel(device->channel);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001214
1215
1216 vstor_packet->flags |= REQUEST_COMPLETION_FLAG;
1217
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001218 vstor_packet->vm_srb.length = (sizeof(struct vmscsi_request) -
1219 vmscsi_size_delta);
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001220
1221
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001222 vstor_packet->vm_srb.sense_info_length = sense_buffer_size;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001223
1224
1225 vstor_packet->vm_srb.data_transfer_length =
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001226 request->payload->range.len;
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001227
1228 vstor_packet->operation = VSTOR_OPERATION_EXECUTE_SRB;
1229
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001230 if (request->payload->range.len) {
1231
1232 ret = vmbus_sendpacket_mpb_desc(outgoing_channel,
1233 request->payload, request->payload_sz,
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001234 vstor_packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001235 (sizeof(struct vstor_packet) -
1236 vmscsi_size_delta),
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001237 (unsigned long)request);
1238 } else {
K. Y. Srinivasan0147dab2015-03-27 00:27:16 -07001239 ret = vmbus_sendpacket(outgoing_channel, vstor_packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001240 (sizeof(struct vstor_packet) -
1241 vmscsi_size_delta),
K. Y. Srinivasan8dcf37d2011-08-27 11:31:22 -07001242 (unsigned long)request,
1243 VM_PKT_DATA_INBAND,
1244 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1245 }
1246
1247 if (ret != 0)
1248 return ret;
1249
1250 atomic_inc(&stor_device->num_outstanding_req);
1251
1252 return ret;
1253}
1254
K. Y. Srinivasan419f2d02011-05-10 07:54:27 -07001255static int storvsc_device_configure(struct scsi_device *sdevice)
1256{
K. Y. Srinivasan419f2d02011-05-10 07:54:27 -07001257
K. Y. Srinivasan419f2d02011-05-10 07:54:27 -07001258 blk_queue_max_segment_size(sdevice->request_queue, PAGE_SIZE);
1259
K. Y. Srinivasan419f2d02011-05-10 07:54:27 -07001260 blk_queue_bounce_limit(sdevice->request_queue, BLK_BOUNCE_ANY);
K. Y. Srinivasan419f2d02011-05-10 07:54:27 -07001261
K. Y. Srinivasan893def32013-06-04 12:05:05 -07001262 blk_queue_rq_timeout(sdevice->request_queue, (storvsc_timeout * HZ));
1263
Vitaly Kuznetsov81988a02015-10-01 14:53:17 -07001264 /* Ensure there are no gaps in presented sgls */
1265 blk_queue_virt_boundary(sdevice->request_queue, PAGE_SIZE - 1);
1266
Olaf Hering3e8f4f42013-02-21 12:04:51 -08001267 sdevice->no_write_same = 1;
1268
K. Y. Srinivasanf3cfabc2014-07-21 16:06:01 -07001269 /*
1270 * Add blist flags to permit the reading of the VPD pages even when
1271 * the target may claim SPC-2 compliance. MSFT targets currently
1272 * claim SPC-2 compliance while they implement post SPC-2 features.
1273 * With this patch we can correctly handle WRITE_SAME_16 issues.
1274 */
1275 sdevice->sdev_bflags |= msft_blist_flags;
1276
K. Y. Srinivasanb0a93d92014-12-16 13:21:45 -08001277 /*
1278 * If the host is WIN8 or WIN8 R2, claim conformance to SPC-3
Keith Mangeb95f5be2015-08-13 08:43:51 -07001279 * if the device is a MSFT virtual device. If the host is
1280 * WIN10 or newer, allow write_same.
K. Y. Srinivasanb0a93d92014-12-16 13:21:45 -08001281 */
1282 if (!strncmp(sdevice->vendor, "Msft", 4)) {
Keith Mangee6c4bc62015-08-13 08:43:50 -07001283 switch (vmstor_proto_version) {
1284 case VMSTOR_PROTO_VERSION_WIN8:
1285 case VMSTOR_PROTO_VERSION_WIN8_1:
K. Y. Srinivasanb0a93d92014-12-16 13:21:45 -08001286 sdevice->scsi_level = SCSI_SPC_3;
1287 break;
1288 }
Keith Mangeb95f5be2015-08-13 08:43:51 -07001289
1290 if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN10)
1291 sdevice->no_write_same = 0;
K. Y. Srinivasanb0a93d92014-12-16 13:21:45 -08001292 }
1293
K. Y. Srinivasan419f2d02011-05-10 07:54:27 -07001294 return 0;
1295}
1296
K. Y. Srinivasan62838ce2011-05-10 07:54:34 -07001297static int storvsc_get_chs(struct scsi_device *sdev, struct block_device * bdev,
1298 sector_t capacity, int *info)
1299{
K. Y. Srinivasan5326fd52011-05-10 07:54:52 -07001300 sector_t nsect = capacity;
1301 sector_t cylinders = nsect;
1302 int heads, sectors_pt;
K. Y. Srinivasan62838ce2011-05-10 07:54:34 -07001303
K. Y. Srinivasan5326fd52011-05-10 07:54:52 -07001304 /*
1305 * We are making up these values; let us keep it simple.
1306 */
1307 heads = 0xff;
1308 sectors_pt = 0x3f; /* Sectors per track */
1309 sector_div(cylinders, heads * sectors_pt);
1310 if ((sector_t)(cylinders + 1) * heads * sectors_pt < nsect)
1311 cylinders = 0xffff;
K. Y. Srinivasan62838ce2011-05-10 07:54:34 -07001312
1313 info[0] = heads;
K. Y. Srinivasan5326fd52011-05-10 07:54:52 -07001314 info[1] = sectors_pt;
1315 info[2] = (int)cylinders;
K. Y. Srinivasan62838ce2011-05-10 07:54:34 -07001316
K. Y. Srinivasan62838ce2011-05-10 07:54:34 -07001317 return 0;
1318}
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001319
K. Y. Srinivasan4b270c82012-01-12 12:37:58 -08001320static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001321{
K. Y. Srinivasan4b270c82012-01-12 12:37:58 -08001322 struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
1323 struct hv_device *device = host_dev->dev;
1324
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001325 struct storvsc_device *stor_device;
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -08001326 struct storvsc_cmd_request *request;
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001327 struct vstor_packet *vstor_packet;
1328 int ret, t;
1329
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001330
K. Y. Srinivasan1eaaddf2011-08-27 11:31:03 -07001331 stor_device = get_out_stor_device(device);
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001332 if (!stor_device)
K. Y. Srinivasana00e8222011-11-08 09:01:43 -08001333 return FAILED;
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001334
1335 request = &stor_device->reset_request;
1336 vstor_packet = &request->vstor_packet;
1337
1338 init_completion(&request->wait_event);
1339
1340 vstor_packet->operation = VSTOR_OPERATION_RESET_BUS;
1341 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
1342 vstor_packet->vm_srb.path_id = stor_device->path_id;
1343
1344 ret = vmbus_sendpacket(device->channel, vstor_packet,
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001345 (sizeof(struct vstor_packet) -
1346 vmscsi_size_delta),
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001347 (unsigned long)&stor_device->reset_request,
1348 VM_PKT_DATA_INBAND,
1349 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1350 if (ret != 0)
K. Y. Srinivasana00e8222011-11-08 09:01:43 -08001351 return FAILED;
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001352
K. Y. Srinivasan46d2eb62011-06-16 13:16:36 -07001353 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
K. Y. Srinivasana00e8222011-11-08 09:01:43 -08001354 if (t == 0)
1355 return TIMEOUT_ERROR;
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001356
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001357
1358 /*
1359 * At this point, all outstanding requests in the adapter
1360 * should have been flushed out and return to us
K. Y. Srinivasan5c1b10a2012-10-02 11:03:31 -07001361 * There is a potential race here where the host may be in
1362 * the process of responding when we return from here.
1363 * Just wait for all in-transit packets to be accounted for
1364 * before we return from here.
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001365 */
K. Y. Srinivasan5c1b10a2012-10-02 11:03:31 -07001366 storvsc_wait_to_drain(stor_device);
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001367
K. Y. Srinivasana00e8222011-11-08 09:01:43 -08001368 return SUCCESS;
K. Y. Srinivasanaa3d7892011-05-10 07:54:37 -07001369}
1370
K. Y. Srinivasan56b26e62014-07-12 09:48:30 -07001371/*
1372 * The host guarantees to respond to each command, although I/O latencies might
1373 * be unbounded on Azure. Reset the timer unconditionally to give the host a
1374 * chance to perform EH.
1375 */
1376static enum blk_eh_timer_return storvsc_eh_timed_out(struct scsi_cmnd *scmnd)
1377{
1378 return BLK_EH_RESET_TIMER;
1379}
1380
K. Y. Srinivasanc77b63b2012-01-12 12:37:56 -08001381static bool storvsc_scsi_cmd_ok(struct scsi_cmnd *scmnd)
Olaf Hering92ae4eb2011-10-10 09:37:39 +02001382{
1383 bool allowed = true;
1384 u8 scsi_op = scmnd->cmnd[0];
1385
1386 switch (scsi_op) {
Olaf Hering3e8f4f42013-02-21 12:04:51 -08001387 /* the host does not handle WRITE_SAME, log accident usage */
1388 case WRITE_SAME:
K. Y. Srinivasanc77b63b2012-01-12 12:37:56 -08001389 /*
1390 * smartd sends this command and the host does not handle
1391 * this. So, don't send it.
1392 */
K. Y. Srinivasan41098f82011-10-14 21:31:57 -07001393 case SET_WINDOW:
K. Y. Srinivasan59e00e72011-11-08 09:01:42 -08001394 scmnd->result = ILLEGAL_REQUEST << 16;
K. Y. Srinivasan41098f82011-10-14 21:31:57 -07001395 allowed = false;
1396 break;
1397 default:
1398 break;
Olaf Hering92ae4eb2011-10-10 09:37:39 +02001399 }
1400 return allowed;
1401}
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001402
K. Y. Srinivasanbab445e2011-11-08 09:01:45 -08001403static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001404{
1405 int ret;
K. Y. Srinivasanbab445e2011-11-08 09:01:45 -08001406 struct hv_host_device *host_dev = shost_priv(host);
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001407 struct hv_device *dev = host_dev->dev;
Christoph Hellwigead37002014-12-29 20:05:09 -08001408 struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd);
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001409 int i;
1410 struct scatterlist *sgl;
1411 unsigned int sg_count = 0;
1412 struct vmscsi_request *vm_srb;
K. Y. Srinivasanaaced992015-03-27 00:27:19 -07001413 struct scatterlist *cur_sgl;
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001414 struct vmbus_packet_mpb_array *payload;
1415 u32 payload_sz;
1416 u32 length;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001417
Keith Mange2492fd72015-08-13 08:43:47 -07001418 if (vmstor_proto_version <= VMSTOR_PROTO_VERSION_WIN8) {
K. Y. Srinivasan8caf92d2014-07-12 09:48:28 -07001419 /*
1420 * On legacy hosts filter unimplemented commands.
1421 * Future hosts are expected to correctly handle
1422 * unsupported commands. Furthermore, it is
1423 * possible that some of the currently
1424 * unsupported commands maybe supported in
1425 * future versions of the host.
1426 */
1427 if (!storvsc_scsi_cmd_ok(scmnd)) {
1428 scmnd->scsi_done(scmnd);
1429 return 0;
1430 }
Olaf Hering92ae4eb2011-10-10 09:37:39 +02001431 }
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001432
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001433 /* Setup the cmd request */
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001434 cmd_request->cmd = scmnd;
1435
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -08001436 vm_srb = &cmd_request->vstor_packet.vm_srb;
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001437 vm_srb->win8_extension.time_out_value = 60;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001438
K. Y. Srinivasanf885fb72014-07-12 09:48:31 -07001439 vm_srb->win8_extension.srb_flags |=
K. Y. Srinivasan8cf308e2015-08-31 08:21:54 -07001440 SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001441
1442 /* Build the SRB */
1443 switch (scmnd->sc_data_direction) {
1444 case DMA_TO_DEVICE:
1445 vm_srb->data_in = WRITE_TYPE;
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001446 vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_OUT;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001447 break;
1448 case DMA_FROM_DEVICE:
1449 vm_srb->data_in = READ_TYPE;
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001450 vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_IN;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001451 break;
Vitaly Kuznetsovcb1cf082015-06-25 18:12:11 +02001452 case DMA_NONE:
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001453 vm_srb->data_in = UNKNOWN_TYPE;
K. Y. Srinivasandc457082015-05-01 11:03:02 -07001454 vm_srb->win8_extension.srb_flags |= SRB_FLAGS_NO_DATA_TRANSFER;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001455 break;
Vitaly Kuznetsovcb1cf082015-06-25 18:12:11 +02001456 default:
1457 /*
1458 * This is DMA_BIDIRECTIONAL or something else we are never
1459 * supposed to see here.
1460 */
1461 WARN(1, "Unexpected data direction: %d\n",
1462 scmnd->sc_data_direction);
1463 return -EINVAL;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001464 }
1465
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001466
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001467 vm_srb->port_number = host_dev->port;
1468 vm_srb->path_id = scmnd->device->channel;
1469 vm_srb->target_id = scmnd->device->id;
1470 vm_srb->lun = scmnd->device->lun;
1471
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001472 vm_srb->cdb_length = scmnd->cmd_len;
1473
1474 memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length);
1475
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001476 sgl = (struct scatterlist *)scsi_sglist(scmnd);
1477 sg_count = scsi_sg_count(scmnd);
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001478
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001479 length = scsi_bufflen(scmnd);
1480 payload = (struct vmbus_packet_mpb_array *)&cmd_request->mpb;
1481 payload_sz = sizeof(cmd_request->mpb);
1482
1483 if (sg_count) {
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001484 if (sg_count > MAX_PAGE_BUFFER_COUNT) {
1485
1486 payload_sz = (sg_count * sizeof(void *) +
1487 sizeof(struct vmbus_packet_mpb_array));
1488 payload = kmalloc(payload_sz, GFP_ATOMIC);
Vitaly Kuznetsov81988a02015-10-01 14:53:17 -07001489 if (!payload)
1490 return SCSI_MLQUEUE_DEVICE_BUSY;
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001491 }
1492
1493 payload->range.len = length;
1494 payload->range.offset = sgl[0].offset;
1495
K. Y. Srinivasanaaced992015-03-27 00:27:19 -07001496 cur_sgl = sgl;
1497 for (i = 0; i < sg_count; i++) {
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001498 payload->range.pfn_array[i] =
K. Y. Srinivasanaaced992015-03-27 00:27:19 -07001499 page_to_pfn(sg_page((cur_sgl)));
1500 cur_sgl = sg_next(cur_sgl);
1501 }
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001502
1503 } else if (scsi_sglist(scmnd)) {
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001504 payload->range.len = length;
1505 payload->range.offset =
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001506 virt_to_phys(scsi_sglist(scmnd)) & (PAGE_SIZE-1);
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001507 payload->range.pfn_array[0] =
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001508 virt_to_phys(scsi_sglist(scmnd)) >> PAGE_SHIFT;
1509 }
1510
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001511 cmd_request->payload = payload;
1512 cmd_request->payload_sz = payload_sz;
1513
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001514 /* Invokes the vsc to start an IO */
K. Y. Srinivasan61eaffc2012-01-12 12:38:07 -08001515 ret = storvsc_do_io(dev, cmd_request);
K. Y. Srinivasan636f0fd2011-05-10 07:54:50 -07001516
K. Y. Srinivasand2598f02011-08-25 09:48:58 -07001517 if (ret == -EAGAIN) {
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001518 /* no more space */
Christoph Hellwigead37002014-12-29 20:05:09 -08001519 return SCSI_MLQUEUE_DEVICE_BUSY;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001520 }
1521
K. Y. Srinivasanc77b63b2012-01-12 12:37:56 -08001522 return 0;
K. Y. Srinivasanc5b463a2011-05-10 07:54:42 -07001523}
1524
Hank Janssenbef4a342009-07-13 16:01:31 -07001525static struct scsi_host_template scsi_driver = {
Greg Kroah-Hartmanff568d32009-09-02 08:37:47 -07001526 .module = THIS_MODULE,
1527 .name = "storvsc_host_t",
Christoph Hellwigead37002014-12-29 20:05:09 -08001528 .cmd_size = sizeof(struct storvsc_cmd_request),
Greg Kroah-Hartmanff568d32009-09-02 08:37:47 -07001529 .bios_param = storvsc_get_chs,
1530 .queuecommand = storvsc_queuecommand,
1531 .eh_host_reset_handler = storvsc_host_reset_handler,
Christoph Hellwigead37002014-12-29 20:05:09 -08001532 .proc_name = "storvsc_host",
K. Y. Srinivasan56b26e62014-07-12 09:48:30 -07001533 .eh_timed_out = storvsc_eh_timed_out,
Greg Kroah-Hartmanff568d32009-09-02 08:37:47 -07001534 .slave_configure = storvsc_device_configure,
K. Y. Srinivasan52f96142014-07-12 09:48:27 -07001535 .cmd_per_lun = 255,
Greg Kroah-Hartmanff568d32009-09-02 08:37:47 -07001536 .this_id = -1,
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001537 .use_clustering = ENABLE_CLUSTERING,
Bill Pemberton454f18a2009-07-27 16:47:24 -04001538 /* Make sure we dont get a sg segment crosses a page boundary */
Greg Kroah-Hartmanff568d32009-09-02 08:37:47 -07001539 .dma_boundary = PAGE_SIZE-1,
Martin K. Petersen54b2b502013-10-23 06:25:40 -04001540 .no_write_same = 1,
Hank Janssenbef4a342009-07-13 16:01:31 -07001541};
1542
K. Y. Srinivasanef52a812011-09-13 10:59:39 -07001543enum {
1544 SCSI_GUID,
1545 IDE_GUID,
K. Y. Srinivasanbde6d0f2013-06-04 12:05:08 -07001546 SFC_GUID,
K. Y. Srinivasanef52a812011-09-13 10:59:39 -07001547};
1548
K. Y. Srinivasand847b5f2011-08-25 09:48:33 -07001549static const struct hv_vmbus_device_id id_table[] = {
Greg Kroah-Hartmanc45cf2d2011-08-25 11:41:33 -07001550 /* SCSI guid */
K. Y. Srinivasan35c3bc22013-01-23 17:42:43 -08001551 { HV_SCSI_GUID,
1552 .driver_data = SCSI_GUID
1553 },
K. Y. Srinivasan21e37742011-08-27 11:31:18 -07001554 /* IDE guid */
K. Y. Srinivasan35c3bc22013-01-23 17:42:43 -08001555 { HV_IDE_GUID,
1556 .driver_data = IDE_GUID
1557 },
K. Y. Srinivasanbde6d0f2013-06-04 12:05:08 -07001558 /* Fibre Channel GUID */
1559 {
1560 HV_SYNTHFC_GUID,
1561 .driver_data = SFC_GUID
1562 },
Greg Kroah-Hartmanc45cf2d2011-08-25 11:41:33 -07001563 { },
K. Y. Srinivasand847b5f2011-08-25 09:48:33 -07001564};
Hank Janssenbef4a342009-07-13 16:01:31 -07001565
K. Y. Srinivasand847b5f2011-08-25 09:48:33 -07001566MODULE_DEVICE_TABLE(vmbus, id_table);
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001567
K. Y. Srinivasan84946892011-09-13 10:59:38 -07001568static int storvsc_probe(struct hv_device *device,
1569 const struct hv_vmbus_device_id *dev_id)
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001570{
1571 int ret;
K. Y. Srinivasanf458aad2015-03-27 00:27:15 -07001572 int num_cpus = num_online_cpus();
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001573 struct Scsi_Host *host;
1574 struct hv_host_device *host_dev;
K. Y. Srinivasanef52a812011-09-13 10:59:39 -07001575 bool dev_is_ide = ((dev_id->driver_data == IDE_GUID) ? true : false);
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001576 int target = 0;
K. Y. Srinivasan6e4198c2011-09-13 10:59:45 -07001577 struct storvsc_device *stor_device;
K. Y. Srinivasan0fb8db22014-12-16 13:21:44 -08001578 int max_luns_per_target;
1579 int max_targets;
1580 int max_channels;
K. Y. Srinivasanf458aad2015-03-27 00:27:15 -07001581 int max_sub_channels = 0;
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001582
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001583 /*
1584 * Based on the windows host we are running on,
1585 * set state to properly communicate with the host.
1586 */
1587
Keith Mange6ee5c612015-08-13 08:43:46 -07001588 if (vmbus_proto_version < VERSION_WIN8) {
K. Y. Srinivasan0fb8db22014-12-16 13:21:44 -08001589 max_luns_per_target = STORVSC_IDE_MAX_LUNS_PER_TARGET;
1590 max_targets = STORVSC_IDE_MAX_TARGETS;
1591 max_channels = STORVSC_IDE_MAX_CHANNELS;
Keith Mange6ee5c612015-08-13 08:43:46 -07001592 } else {
K. Y. Srinivasan0fb8db22014-12-16 13:21:44 -08001593 max_luns_per_target = STORVSC_MAX_LUNS_PER_TARGET;
1594 max_targets = STORVSC_MAX_TARGETS;
1595 max_channels = STORVSC_MAX_CHANNELS;
K. Y. Srinivasanf458aad2015-03-27 00:27:15 -07001596 /*
1597 * On Windows8 and above, we support sub-channels for storage.
1598 * The number of sub-channels offerred is based on the number of
1599 * VCPUs in the guest.
1600 */
1601 max_sub_channels = (num_cpus / storvsc_vcpus_per_sub_channel);
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001602 }
1603
K. Y. Srinivasanf458aad2015-03-27 00:27:15 -07001604 scsi_driver.can_queue = (max_outstanding_req_per_channel *
1605 (max_sub_channels + 1));
1606
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001607 host = scsi_host_alloc(&scsi_driver,
1608 sizeof(struct hv_host_device));
1609 if (!host)
1610 return -ENOMEM;
1611
K. Y. Srinivasan7f33f302011-11-08 09:01:44 -08001612 host_dev = shost_priv(host);
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001613 memset(host_dev, 0, sizeof(struct hv_host_device));
1614
1615 host_dev->port = host->host_no;
1616 host_dev->dev = device;
1617
K. Y. Srinivasan4e03e692011-11-08 09:01:40 -08001618
K. Y. Srinivasana13d35a2011-09-13 10:59:46 -07001619 stor_device = kzalloc(sizeof(struct storvsc_device), GFP_KERNEL);
K. Y. Srinivasan6e4198c2011-09-13 10:59:45 -07001620 if (!stor_device) {
K. Y. Srinivasan225ce6e2011-11-08 09:01:41 -08001621 ret = -ENOMEM;
K. Y. Srinivasance3e3012011-12-01 04:59:20 -08001622 goto err_out0;
K. Y. Srinivasan6e4198c2011-09-13 10:59:45 -07001623 }
1624
K. Y. Srinivasana13d35a2011-09-13 10:59:46 -07001625 stor_device->destroy = false;
K. Y. Srinivasan6f94d5d2013-06-04 12:05:07 -07001626 stor_device->open_sub_channel = false;
K. Y. Srinivasana13d35a2011-09-13 10:59:46 -07001627 init_waitqueue_head(&stor_device->waiting_to_drain);
1628 stor_device->device = device;
K. Y. Srinivasancd654ea2011-09-13 10:59:48 -07001629 stor_device->host = host;
1630 hv_set_drvdata(device, stor_device);
K. Y. Srinivasana13d35a2011-09-13 10:59:46 -07001631
K. Y. Srinivasan6e4198c2011-09-13 10:59:45 -07001632 stor_device->port_number = host->host_no;
1633 ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size);
K. Y. Srinivasan225ce6e2011-11-08 09:01:41 -08001634 if (ret)
K. Y. Srinivasance3e3012011-12-01 04:59:20 -08001635 goto err_out1;
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001636
K. Y. Srinivasan6e4198c2011-09-13 10:59:45 -07001637 host_dev->path = stor_device->path_id;
1638 host_dev->target = stor_device->target_id;
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001639
K. Y. Srinivasan4cd83ec2014-07-12 09:48:26 -07001640 switch (dev_id->driver_data) {
1641 case SFC_GUID:
1642 host->max_lun = STORVSC_FC_MAX_LUNS_PER_TARGET;
1643 host->max_id = STORVSC_FC_MAX_TARGETS;
1644 host->max_channel = STORVSC_FC_MAX_CHANNELS - 1;
1645 break;
1646
1647 case SCSI_GUID:
K. Y. Srinivasan0fb8db22014-12-16 13:21:44 -08001648 host->max_lun = max_luns_per_target;
1649 host->max_id = max_targets;
1650 host->max_channel = max_channels - 1;
K. Y. Srinivasan4cd83ec2014-07-12 09:48:26 -07001651 break;
1652
1653 default:
1654 host->max_lun = STORVSC_IDE_MAX_LUNS_PER_TARGET;
1655 host->max_id = STORVSC_IDE_MAX_TARGETS;
1656 host->max_channel = STORVSC_IDE_MAX_CHANNELS - 1;
1657 break;
1658 }
Mike Sterlingcf55f4a2011-09-06 16:10:55 -07001659 /* max cmd length */
1660 host->max_cmd_len = STORVSC_MAX_CMD_LEN;
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001661
K. Y. Srinivasanbe0cf6c2015-03-27 00:27:20 -07001662 /*
1663 * set the table size based on the info we got
1664 * from the host.
1665 */
1666 host->sg_tablesize = (stor_device->max_transfer_bytes >> PAGE_SHIFT);
1667
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001668 /* Register the HBA and start the scsi bus scan */
1669 ret = scsi_add_host(host, &device->device);
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001670 if (ret != 0)
K. Y. Srinivasance3e3012011-12-01 04:59:20 -08001671 goto err_out2;
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001672
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001673 if (!dev_is_ide) {
1674 scsi_scan_host(host);
K. Y. Srinivasan59d22952012-01-12 12:37:55 -08001675 } else {
1676 target = (device->dev_instance.b[5] << 8 |
1677 device->dev_instance.b[4]);
1678 ret = scsi_add_device(host, 0, target, 0);
1679 if (ret) {
1680 scsi_remove_host(host);
1681 goto err_out2;
1682 }
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001683 }
1684 return 0;
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001685
K. Y. Srinivasance3e3012011-12-01 04:59:20 -08001686err_out2:
K. Y. Srinivasan225ce6e2011-11-08 09:01:41 -08001687 /*
1688 * Once we have connected with the host, we would need to
1689 * to invoke storvsc_dev_remove() to rollback this state and
1690 * this call also frees up the stor_device; hence the jump around
K. Y. Srinivasance3e3012011-12-01 04:59:20 -08001691 * err_out1 label.
K. Y. Srinivasan225ce6e2011-11-08 09:01:41 -08001692 */
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001693 storvsc_dev_remove(device);
K. Y. Srinivasance3e3012011-12-01 04:59:20 -08001694 goto err_out0;
K. Y. Srinivasan225ce6e2011-11-08 09:01:41 -08001695
1696err_out1:
K. Y. Srinivasance3e3012011-12-01 04:59:20 -08001697 kfree(stor_device);
K. Y. Srinivasan225ce6e2011-11-08 09:01:41 -08001698
1699err_out0:
K. Y. Srinivasanbd1f5d62011-08-27 11:31:17 -07001700 scsi_host_put(host);
K. Y. Srinivasan225ce6e2011-11-08 09:01:41 -08001701 return ret;
K. Y. Srinivasanf5c78872011-05-10 07:54:43 -07001702}
1703
K. Y. Srinivasanddcbf652012-01-12 12:37:59 -08001704static int storvsc_remove(struct hv_device *dev)
1705{
1706 struct storvsc_device *stor_device = hv_get_drvdata(dev);
1707 struct Scsi_Host *host = stor_device->host;
1708
1709 scsi_remove_host(host);
1710 storvsc_dev_remove(dev);
1711 scsi_host_put(host);
1712
1713 return 0;
1714}
1715
K. Y. Srinivasan40bf63e2011-05-10 07:56:09 -07001716static struct hv_driver storvsc_drv = {
K. Y. Srinivasanfafb0ef2011-11-08 09:01:46 -08001717 .name = KBUILD_MODNAME,
K. Y. Srinivasand847b5f2011-08-25 09:48:33 -07001718 .id_table = id_table,
K. Y. Srinivasan40bf63e2011-05-10 07:56:09 -07001719 .probe = storvsc_probe,
1720 .remove = storvsc_remove,
K. Y. Srinivasan39ae6fa2011-05-10 07:54:46 -07001721};
K. Y. Srinivasan7bd05b92011-05-10 07:54:45 -07001722
K. Y. Srinivasand9bbae82011-06-06 15:49:27 -07001723static int __init storvsc_drv_init(void)
Hank Janssenbef4a342009-07-13 16:01:31 -07001724{
K. Y. Srinivasan01415ab32011-05-10 07:55:58 -07001725
1726 /*
1727 * Divide the ring buffer data size (which is 1 page less
1728 * than the ring buffer size since that page is reserved for
1729 * the ring buffer indices) by the max request size (which is
1730 * vmbus_channel_packet_multipage_buffer + struct vstor_packet + u64)
1731 */
K. Y. Srinivasan01415ab32011-05-10 07:55:58 -07001732 max_outstanding_req_per_channel =
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -07001733 ((storvsc_ringbuffer_size - PAGE_SIZE) /
1734 ALIGN(MAX_MULTIPAGE_BUFFER_PACKET +
K. Y. Srinivasan8b612fa2013-06-04 12:05:06 -07001735 sizeof(struct vstor_packet) + sizeof(u64) -
1736 vmscsi_size_delta,
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -07001737 sizeof(u64)));
Hank Janssenbef4a342009-07-13 16:01:31 -07001738
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -07001739 return vmbus_driver_register(&storvsc_drv);
Hank Janssenbef4a342009-07-13 16:01:31 -07001740}
1741
K. Y. Srinivasanc63ba9e2011-06-06 15:49:26 -07001742static void __exit storvsc_drv_exit(void)
Hank Janssenbef4a342009-07-13 16:01:31 -07001743{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -07001744 vmbus_driver_unregister(&storvsc_drv);
Hank Janssenbef4a342009-07-13 16:01:31 -07001745}
1746
Greg Kroah-Hartmanff568d32009-09-02 08:37:47 -07001747MODULE_LICENSE("GPL");
Stephen Hemminger3afc7cc32010-05-06 21:44:45 -07001748MODULE_DESCRIPTION("Microsoft Hyper-V virtual storage driver");
K. Y. Srinivasand9bbae82011-06-06 15:49:27 -07001749module_init(storvsc_drv_init);
K. Y. Srinivasanc63ba9e2011-06-06 15:49:26 -07001750module_exit(storvsc_drv_exit);