1
2
3
4
5
6
7
8
9
10
11#include <linux/kernel.h>
12#include <linux/wait.h>
13#include <linux/sched.h>
14#include <linux/completion.h>
15#include <linux/string.h>
16#include <linux/mm.h>
17#include <linux/delay.h>
18#include <linux/init.h>
19#include <linux/slab.h>
20#include <linux/module.h>
21#include <linux/device.h>
22#include <linux/hyperv.h>
23#include <linux/blkdev.h>
24#include <scsi/scsi.h>
25#include <scsi/scsi_cmnd.h>
26#include <scsi/scsi_host.h>
27#include <scsi/scsi_device.h>
28#include <scsi/scsi_tcq.h>
29#include <scsi/scsi_eh.h>
30#include <scsi/scsi_devinfo.h>
31#include <scsi/scsi_dbg.h>
32#include <scsi/scsi_transport_fc.h>
33#include <scsi/scsi_transport.h>
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53#define VMSTOR_PROTO_VERSION(MAJOR_, MINOR_) ((((MAJOR_) & 0xff) << 8) | \
54 (((MINOR_) & 0xff)))
55
56#define VMSTOR_PROTO_VERSION_WIN6 VMSTOR_PROTO_VERSION(2, 0)
57#define VMSTOR_PROTO_VERSION_WIN7 VMSTOR_PROTO_VERSION(4, 2)
58#define VMSTOR_PROTO_VERSION_WIN8 VMSTOR_PROTO_VERSION(5, 1)
59#define VMSTOR_PROTO_VERSION_WIN8_1 VMSTOR_PROTO_VERSION(6, 0)
60#define VMSTOR_PROTO_VERSION_WIN10 VMSTOR_PROTO_VERSION(6, 2)
61
62
63enum vstor_packet_operation {
64 VSTOR_OPERATION_COMPLETE_IO = 1,
65 VSTOR_OPERATION_REMOVE_DEVICE = 2,
66 VSTOR_OPERATION_EXECUTE_SRB = 3,
67 VSTOR_OPERATION_RESET_LUN = 4,
68 VSTOR_OPERATION_RESET_ADAPTER = 5,
69 VSTOR_OPERATION_RESET_BUS = 6,
70 VSTOR_OPERATION_BEGIN_INITIALIZATION = 7,
71 VSTOR_OPERATION_END_INITIALIZATION = 8,
72 VSTOR_OPERATION_QUERY_PROTOCOL_VERSION = 9,
73 VSTOR_OPERATION_QUERY_PROPERTIES = 10,
74 VSTOR_OPERATION_ENUMERATE_BUS = 11,
75 VSTOR_OPERATION_FCHBA_DATA = 12,
76 VSTOR_OPERATION_CREATE_SUB_CHANNELS = 13,
77 VSTOR_OPERATION_MAXIMUM = 13
78};
79
80
81
82
83
84struct hv_fc_wwn_packet {
85 u8 primary_active;
86 u8 reserved1[3];
87 u8 primary_port_wwn[8];
88 u8 primary_node_wwn[8];
89 u8 secondary_port_wwn[8];
90 u8 secondary_node_wwn[8];
91};
92
93
94
95
96
97
98
99#define SRB_FLAGS_QUEUE_ACTION_ENABLE 0x00000002
100#define SRB_FLAGS_DISABLE_DISCONNECT 0x00000004
101#define SRB_FLAGS_DISABLE_SYNCH_TRANSFER 0x00000008
102#define SRB_FLAGS_BYPASS_FROZEN_QUEUE 0x00000010
103#define SRB_FLAGS_DISABLE_AUTOSENSE 0x00000020
104#define SRB_FLAGS_DATA_IN 0x00000040
105#define SRB_FLAGS_DATA_OUT 0x00000080
106#define SRB_FLAGS_NO_DATA_TRANSFER 0x00000000
107#define SRB_FLAGS_UNSPECIFIED_DIRECTION (SRB_FLAGS_DATA_IN | SRB_FLAGS_DATA_OUT)
108#define SRB_FLAGS_NO_QUEUE_FREEZE 0x00000100
109#define SRB_FLAGS_ADAPTER_CACHE_ENABLE 0x00000200
110#define SRB_FLAGS_FREE_SENSE_BUFFER 0x00000400
111
112
113
114
115#define SRB_FLAGS_D3_PROCESSING 0x00000800
116#define SRB_FLAGS_IS_ACTIVE 0x00010000
117#define SRB_FLAGS_ALLOCATED_FROM_ZONE 0x00020000
118#define SRB_FLAGS_SGLIST_FROM_POOL 0x00040000
119#define SRB_FLAGS_BYPASS_LOCKED_QUEUE 0x00080000
120#define SRB_FLAGS_NO_KEEP_AWAKE 0x00100000
121#define SRB_FLAGS_PORT_DRIVER_ALLOCSENSE 0x00200000
122#define SRB_FLAGS_PORT_DRIVER_SENSEHASPORT 0x00400000
123#define SRB_FLAGS_DONT_START_NEXT_PACKET 0x00800000
124#define SRB_FLAGS_PORT_DRIVER_RESERVED 0x0F000000
125#define SRB_FLAGS_CLASS_DRIVER_RESERVED 0xF0000000
126
127#define SP_UNTAGGED ((unsigned char) ~0)
128#define SRB_SIMPLE_TAG_REQUEST 0x20
129
130
131
132
133
134
135#define STORVSC_MAX_CMD_LEN 0x10
136
137#define POST_WIN7_STORVSC_SENSE_BUFFER_SIZE 0x14
138#define PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE 0x12
139
140#define STORVSC_SENSE_BUFFER_SIZE 0x14
141#define STORVSC_MAX_BUF_LEN_WITH_PADDING 0x14
142
143
144
145
146
147
148
149static int sense_buffer_size = PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE;
150
151
152
153
154
155
156static int vmstor_proto_version;
157
158#define STORVSC_LOGGING_NONE 0
159#define STORVSC_LOGGING_ERROR 1
160#define STORVSC_LOGGING_WARN 2
161
162static int logging_level = STORVSC_LOGGING_ERROR;
163module_param(logging_level, int, S_IRUGO|S_IWUSR);
164MODULE_PARM_DESC(logging_level,
165 "Logging level, 0 - None, 1 - Error (default), 2 - Warning.");
166
167static inline bool do_logging(int level)
168{
169 return logging_level >= level;
170}
171
172#define storvsc_log(dev, level, fmt, ...) \
173do { \
174 if (do_logging(level)) \
175 dev_warn(&(dev)->device, fmt, ##__VA_ARGS__); \
176} while (0)
177
178struct vmscsi_win8_extension {
179
180
181
182 u16 reserve;
183 u8 queue_tag;
184 u8 queue_action;
185 u32 srb_flags;
186 u32 time_out_value;
187 u32 queue_sort_ey;
188} __packed;
189
190struct vmscsi_request {
191 u16 length;
192 u8 srb_status;
193 u8 scsi_status;
194
195 u8 port_number;
196 u8 path_id;
197 u8 target_id;
198 u8 lun;
199
200 u8 cdb_length;
201 u8 sense_info_length;
202 u8 data_in;
203 u8 reserved;
204
205 u32 data_transfer_length;
206
207 union {
208 u8 cdb[STORVSC_MAX_CMD_LEN];
209 u8 sense_data[STORVSC_SENSE_BUFFER_SIZE];
210 u8 reserved_array[STORVSC_MAX_BUF_LEN_WITH_PADDING];
211 };
212
213
214
215 struct vmscsi_win8_extension win8_extension;
216
217} __attribute((packed));
218
219
220
221
222struct vmstor_protocol {
223 int protocol_version;
224 int sense_buffer_size;
225 int vmscsi_size_delta;
226};
227
228
229static const struct vmstor_protocol vmstor_protocols[] = {
230 {
231 VMSTOR_PROTO_VERSION_WIN10,
232 POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
233 0
234 },
235 {
236 VMSTOR_PROTO_VERSION_WIN8_1,
237 POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
238 0
239 },
240 {
241 VMSTOR_PROTO_VERSION_WIN8,
242 POST_WIN7_STORVSC_SENSE_BUFFER_SIZE,
243 0
244 },
245 {
246 VMSTOR_PROTO_VERSION_WIN7,
247 PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE,
248 sizeof(struct vmscsi_win8_extension),
249 },
250 {
251 VMSTOR_PROTO_VERSION_WIN6,
252 PRE_WIN8_STORVSC_SENSE_BUFFER_SIZE,
253 sizeof(struct vmscsi_win8_extension),
254 }
255};
256
257
258
259
260
261
262
263#define STORAGE_CHANNEL_SUPPORTS_MULTI_CHANNEL 0x1
264
265struct vmstorage_channel_properties {
266 u32 reserved;
267 u16 max_channel_cnt;
268 u16 reserved1;
269
270 u32 flags;
271 u32 max_transfer_bytes;
272
273 u64 reserved2;
274} __packed;
275
276
277struct vmstorage_protocol_version {
278
279 u16 major_minor;
280
281
282
283
284
285
286
287
288 u16 revision;
289} __packed;
290
291
292#define STORAGE_CHANNEL_REMOVABLE_FLAG 0x1
293#define STORAGE_CHANNEL_EMULATED_IDE_FLAG 0x2
294
295struct vstor_packet {
296
297 enum vstor_packet_operation operation;
298
299
300 u32 flags;
301
302
303 u32 status;
304
305
306 union {
307
308
309
310
311 struct vmscsi_request vm_srb;
312
313
314 struct vmstorage_channel_properties storage_channel_properties;
315
316
317 struct vmstorage_protocol_version version;
318
319
320 struct hv_fc_wwn_packet wwn_packet;
321
322
323 u16 sub_channel_count;
324
325
326 u8 buffer[0x34];
327 };
328} __packed;
329
330
331
332
333
334
335
336
337#define REQUEST_COMPLETION_FLAG 0x1
338
339
340enum storvsc_request_type {
341 WRITE_TYPE = 0,
342 READ_TYPE,
343 UNKNOWN_TYPE,
344};
345
346
347
348
349
350#define SRB_STATUS_AUTOSENSE_VALID 0x80
351#define SRB_STATUS_QUEUE_FROZEN 0x40
352#define SRB_STATUS_INVALID_LUN 0x20
353#define SRB_STATUS_SUCCESS 0x01
354#define SRB_STATUS_ABORTED 0x02
355#define SRB_STATUS_ERROR 0x04
356#define SRB_STATUS_DATA_OVERRUN 0x12
357
358#define SRB_STATUS(status) \
359 (status & ~(SRB_STATUS_AUTOSENSE_VALID | SRB_STATUS_QUEUE_FROZEN))
360
361
362
363
364static int storvsc_ringbuffer_size = (128 * 1024);
365static u32 max_outstanding_req_per_channel;
366static int storvsc_change_queue_depth(struct scsi_device *sdev, int queue_depth);
367
368static int storvsc_vcpus_per_sub_channel = 4;
369static unsigned int storvsc_max_hw_queues;
370
371module_param(storvsc_ringbuffer_size, int, S_IRUGO);
372MODULE_PARM_DESC(storvsc_ringbuffer_size, "Ring buffer size (bytes)");
373
374module_param(storvsc_max_hw_queues, uint, 0644);
375MODULE_PARM_DESC(storvsc_max_hw_queues, "Maximum number of hardware queues");
376
377module_param(storvsc_vcpus_per_sub_channel, int, S_IRUGO);
378MODULE_PARM_DESC(storvsc_vcpus_per_sub_channel, "Ratio of VCPUs to subchannels");
379
380static int ring_avail_percent_lowater = 10;
381module_param(ring_avail_percent_lowater, int, S_IRUGO);
382MODULE_PARM_DESC(ring_avail_percent_lowater,
383 "Select a channel if available ring size > this in percent");
384
385
386
387
388static int storvsc_timeout = 180;
389
390#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
391static struct scsi_transport_template *fc_transport_template;
392#endif
393
394static struct scsi_host_template scsi_driver;
395static void storvsc_on_channel_callback(void *context);
396
397#define STORVSC_MAX_LUNS_PER_TARGET 255
398#define STORVSC_MAX_TARGETS 2
399#define STORVSC_MAX_CHANNELS 8
400
401#define STORVSC_FC_MAX_LUNS_PER_TARGET 255
402#define STORVSC_FC_MAX_TARGETS 128
403#define STORVSC_FC_MAX_CHANNELS 8
404
405#define STORVSC_IDE_MAX_LUNS_PER_TARGET 64
406#define STORVSC_IDE_MAX_TARGETS 1
407#define STORVSC_IDE_MAX_CHANNELS 1
408
409
410
411
412
413
414#define STORVSC_MAX_PKT_SIZE (sizeof(struct vmpacket_descriptor) +\
415 sizeof(struct vstor_packet))
416
417struct storvsc_cmd_request {
418 struct scsi_cmnd *cmd;
419
420 struct hv_device *device;
421
422
423 struct completion wait_event;
424
425 struct vmbus_channel_packet_multipage_buffer mpb;
426 struct vmbus_packet_mpb_array *payload;
427 u32 payload_sz;
428
429 struct vstor_packet vstor_packet;
430};
431
432
433
434struct storvsc_device {
435 struct hv_device *device;
436
437 bool destroy;
438 bool drain_notify;
439 atomic_t num_outstanding_req;
440 struct Scsi_Host *host;
441
442 wait_queue_head_t waiting_to_drain;
443
444
445
446
447
448
449 unsigned int port_number;
450 unsigned char path_id;
451 unsigned char target_id;
452
453
454
455
456
457
458
459
460
461
462 int vmscsi_size_delta;
463
464
465
466
467 u32 max_transfer_bytes;
468
469
470
471 u16 num_sc;
472 struct vmbus_channel **stor_chns;
473
474
475
476 struct cpumask alloced_cpus;
477
478
479
480
481 spinlock_t lock;
482
483 struct storvsc_cmd_request init_request;
484 struct storvsc_cmd_request reset_request;
485
486
487
488 u64 node_name;
489 u64 port_name;
490#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
491 struct fc_rport *rport;
492#endif
493};
494
495struct hv_host_device {
496 struct hv_device *dev;
497 unsigned int port;
498 unsigned char path;
499 unsigned char target;
500 struct workqueue_struct *handle_error_wq;
501 struct work_struct host_scan_work;
502 struct Scsi_Host *host;
503};
504
505struct storvsc_scan_work {
506 struct work_struct work;
507 struct Scsi_Host *host;
508 u8 lun;
509 u8 tgt_id;
510};
511
512static void storvsc_device_scan(struct work_struct *work)
513{
514 struct storvsc_scan_work *wrk;
515 struct scsi_device *sdev;
516
517 wrk = container_of(work, struct storvsc_scan_work, work);
518
519 sdev = scsi_device_lookup(wrk->host, 0, wrk->tgt_id, wrk->lun);
520 if (!sdev)
521 goto done;
522 scsi_rescan_device(&sdev->sdev_gendev);
523 scsi_device_put(sdev);
524
525done:
526 kfree(wrk);
527}
528
529static void storvsc_host_scan(struct work_struct *work)
530{
531 struct Scsi_Host *host;
532 struct scsi_device *sdev;
533 struct hv_host_device *host_device =
534 container_of(work, struct hv_host_device, host_scan_work);
535
536 host = host_device->host;
537
538
539
540
541
542
543
544
545
546
547
548 mutex_lock(&host->scan_mutex);
549 shost_for_each_device(sdev, host)
550 scsi_test_unit_ready(sdev, 1, 1, NULL);
551 mutex_unlock(&host->scan_mutex);
552
553
554
555 scsi_scan_host(host);
556}
557
558static void storvsc_remove_lun(struct work_struct *work)
559{
560 struct storvsc_scan_work *wrk;
561 struct scsi_device *sdev;
562
563 wrk = container_of(work, struct storvsc_scan_work, work);
564 if (!scsi_host_get(wrk->host))
565 goto done;
566
567 sdev = scsi_device_lookup(wrk->host, 0, wrk->tgt_id, wrk->lun);
568
569 if (sdev) {
570 scsi_remove_device(sdev);
571 scsi_device_put(sdev);
572 }
573 scsi_host_put(wrk->host);
574
575done:
576 kfree(wrk);
577}
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595static inline struct storvsc_device *get_out_stor_device(
596 struct hv_device *device)
597{
598 struct storvsc_device *stor_device;
599
600 stor_device = hv_get_drvdata(device);
601
602 if (stor_device && stor_device->destroy)
603 stor_device = NULL;
604
605 return stor_device;
606}
607
608
609static inline void storvsc_wait_to_drain(struct storvsc_device *dev)
610{
611 dev->drain_notify = true;
612 wait_event(dev->waiting_to_drain,
613 atomic_read(&dev->num_outstanding_req) == 0);
614 dev->drain_notify = false;
615}
616
617static inline struct storvsc_device *get_in_stor_device(
618 struct hv_device *device)
619{
620 struct storvsc_device *stor_device;
621
622 stor_device = hv_get_drvdata(device);
623
624 if (!stor_device)
625 goto get_in_err;
626
627
628
629
630
631
632 if (stor_device->destroy &&
633 (atomic_read(&stor_device->num_outstanding_req) == 0))
634 stor_device = NULL;
635
636get_in_err:
637 return stor_device;
638
639}
640
641static void storvsc_change_target_cpu(struct vmbus_channel *channel, u32 old,
642 u32 new)
643{
644 struct storvsc_device *stor_device;
645 struct vmbus_channel *cur_chn;
646 bool old_is_alloced = false;
647 struct hv_device *device;
648 unsigned long flags;
649 int cpu;
650
651 device = channel->primary_channel ?
652 channel->primary_channel->device_obj
653 : channel->device_obj;
654 stor_device = get_out_stor_device(device);
655 if (!stor_device)
656 return;
657
658
659 spin_lock_irqsave(&stor_device->lock, flags);
660
661
662
663
664
665
666 if (device->channel != channel && device->channel->target_cpu == old) {
667 cur_chn = device->channel;
668 old_is_alloced = true;
669 goto old_is_alloced;
670 }
671 list_for_each_entry(cur_chn, &device->channel->sc_list, sc_list) {
672 if (cur_chn == channel)
673 continue;
674 if (cur_chn->target_cpu == old) {
675 old_is_alloced = true;
676 goto old_is_alloced;
677 }
678 }
679
680old_is_alloced:
681 if (old_is_alloced)
682 WRITE_ONCE(stor_device->stor_chns[old], cur_chn);
683 else
684 cpumask_clear_cpu(old, &stor_device->alloced_cpus);
685
686
687 for_each_possible_cpu(cpu) {
688 if (stor_device->stor_chns[cpu] && !cpumask_test_cpu(
689 cpu, &stor_device->alloced_cpus))
690 WRITE_ONCE(stor_device->stor_chns[cpu], NULL);
691 }
692
693 WRITE_ONCE(stor_device->stor_chns[new], channel);
694 cpumask_set_cpu(new, &stor_device->alloced_cpus);
695
696 spin_unlock_irqrestore(&stor_device->lock, flags);
697}
698
699static u64 storvsc_next_request_id(struct vmbus_channel *channel, u64 rqst_addr)
700{
701 struct storvsc_cmd_request *request =
702 (struct storvsc_cmd_request *)(unsigned long)rqst_addr;
703
704 if (rqst_addr == VMBUS_RQST_INIT)
705 return VMBUS_RQST_INIT;
706 if (rqst_addr == VMBUS_RQST_RESET)
707 return VMBUS_RQST_RESET;
708
709
710
711
712
713 return (u64)blk_mq_unique_tag(request->cmd->request) + 1;
714}
715
716static void handle_sc_creation(struct vmbus_channel *new_sc)
717{
718 struct hv_device *device = new_sc->primary_channel->device_obj;
719 struct device *dev = &device->device;
720 struct storvsc_device *stor_device;
721 struct vmstorage_channel_properties props;
722 int ret;
723
724 stor_device = get_out_stor_device(device);
725 if (!stor_device)
726 return;
727
728 memset(&props, 0, sizeof(struct vmstorage_channel_properties));
729 new_sc->max_pkt_size = STORVSC_MAX_PKT_SIZE;
730
731 new_sc->next_request_id_callback = storvsc_next_request_id;
732
733 ret = vmbus_open(new_sc,
734 storvsc_ringbuffer_size,
735 storvsc_ringbuffer_size,
736 (void *)&props,
737 sizeof(struct vmstorage_channel_properties),
738 storvsc_on_channel_callback, new_sc);
739
740
741 if (ret != 0) {
742 dev_err(dev, "Failed to open sub-channel: err=%d\n", ret);
743 return;
744 }
745
746 new_sc->change_target_cpu_callback = storvsc_change_target_cpu;
747
748
749 stor_device->stor_chns[new_sc->target_cpu] = new_sc;
750 cpumask_set_cpu(new_sc->target_cpu, &stor_device->alloced_cpus);
751}
752
753static void handle_multichannel_storage(struct hv_device *device, int max_chns)
754{
755 struct device *dev = &device->device;
756 struct storvsc_device *stor_device;
757 int num_sc;
758 struct storvsc_cmd_request *request;
759 struct vstor_packet *vstor_packet;
760 int ret, t;
761
762
763
764
765
766
767
768
769 num_sc = min((int)(num_online_cpus() - 1), max_chns);
770 if (!num_sc)
771 return;
772
773 stor_device = get_out_stor_device(device);
774 if (!stor_device)
775 return;
776
777 stor_device->num_sc = num_sc;
778 request = &stor_device->init_request;
779 vstor_packet = &request->vstor_packet;
780
781
782
783
784 vmbus_set_sc_create_callback(device->channel, handle_sc_creation);
785
786
787
788
789 memset(request, 0, sizeof(struct storvsc_cmd_request));
790 init_completion(&request->wait_event);
791 vstor_packet->operation = VSTOR_OPERATION_CREATE_SUB_CHANNELS;
792 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
793 vstor_packet->sub_channel_count = num_sc;
794
795 ret = vmbus_sendpacket(device->channel, vstor_packet,
796 (sizeof(struct vstor_packet) -
797 stor_device->vmscsi_size_delta),
798 VMBUS_RQST_INIT,
799 VM_PKT_DATA_INBAND,
800 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
801
802 if (ret != 0) {
803 dev_err(dev, "Failed to create sub-channel: err=%d\n", ret);
804 return;
805 }
806
807 t = wait_for_completion_timeout(&request->wait_event, 10*HZ);
808 if (t == 0) {
809 dev_err(dev, "Failed to create sub-channel: timed out\n");
810 return;
811 }
812
813 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
814 vstor_packet->status != 0) {
815 dev_err(dev, "Failed to create sub-channel: op=%d, sts=%d\n",
816 vstor_packet->operation, vstor_packet->status);
817 return;
818 }
819
820
821
822
823
824
825}
826
827static void cache_wwn(struct storvsc_device *stor_device,
828 struct vstor_packet *vstor_packet)
829{
830
831
832
833 if (vstor_packet->wwn_packet.primary_active) {
834 stor_device->node_name =
835 wwn_to_u64(vstor_packet->wwn_packet.primary_node_wwn);
836 stor_device->port_name =
837 wwn_to_u64(vstor_packet->wwn_packet.primary_port_wwn);
838 } else {
839 stor_device->node_name =
840 wwn_to_u64(vstor_packet->wwn_packet.secondary_node_wwn);
841 stor_device->port_name =
842 wwn_to_u64(vstor_packet->wwn_packet.secondary_port_wwn);
843 }
844}
845
846
847static int storvsc_execute_vstor_op(struct hv_device *device,
848 struct storvsc_cmd_request *request,
849 bool status_check)
850{
851 struct storvsc_device *stor_device;
852 struct vstor_packet *vstor_packet;
853 int ret, t;
854
855 stor_device = get_out_stor_device(device);
856 if (!stor_device)
857 return -ENODEV;
858
859 vstor_packet = &request->vstor_packet;
860
861 init_completion(&request->wait_event);
862 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
863
864 ret = vmbus_sendpacket(device->channel, vstor_packet,
865 (sizeof(struct vstor_packet) -
866 stor_device->vmscsi_size_delta),
867 VMBUS_RQST_INIT,
868 VM_PKT_DATA_INBAND,
869 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
870 if (ret != 0)
871 return ret;
872
873 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
874 if (t == 0)
875 return -ETIMEDOUT;
876
877 if (!status_check)
878 return ret;
879
880 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO ||
881 vstor_packet->status != 0)
882 return -EINVAL;
883
884 return ret;
885}
886
887static int storvsc_channel_init(struct hv_device *device, bool is_fc)
888{
889 struct storvsc_device *stor_device;
890 struct storvsc_cmd_request *request;
891 struct vstor_packet *vstor_packet;
892 int ret, i;
893 int max_chns;
894 bool process_sub_channels = false;
895
896 stor_device = get_out_stor_device(device);
897 if (!stor_device)
898 return -ENODEV;
899
900 request = &stor_device->init_request;
901 vstor_packet = &request->vstor_packet;
902
903
904
905
906
907 memset(request, 0, sizeof(struct storvsc_cmd_request));
908 vstor_packet->operation = VSTOR_OPERATION_BEGIN_INITIALIZATION;
909 ret = storvsc_execute_vstor_op(device, request, true);
910 if (ret)
911 return ret;
912
913
914
915
916 for (i = 0; i < ARRAY_SIZE(vmstor_protocols); i++) {
917
918 memset(vstor_packet, 0, sizeof(struct vstor_packet));
919 vstor_packet->operation =
920 VSTOR_OPERATION_QUERY_PROTOCOL_VERSION;
921
922 vstor_packet->version.major_minor =
923 vmstor_protocols[i].protocol_version;
924
925
926
927
928 vstor_packet->version.revision = 0;
929 ret = storvsc_execute_vstor_op(device, request, false);
930 if (ret != 0)
931 return ret;
932
933 if (vstor_packet->operation != VSTOR_OPERATION_COMPLETE_IO)
934 return -EINVAL;
935
936 if (vstor_packet->status == 0) {
937 vmstor_proto_version =
938 vmstor_protocols[i].protocol_version;
939
940 sense_buffer_size =
941 vmstor_protocols[i].sense_buffer_size;
942
943 stor_device->vmscsi_size_delta =
944 vmstor_protocols[i].vmscsi_size_delta;
945
946 break;
947 }
948 }
949
950 if (vstor_packet->status != 0)
951 return -EINVAL;
952
953
954 memset(vstor_packet, 0, sizeof(struct vstor_packet));
955 vstor_packet->operation = VSTOR_OPERATION_QUERY_PROPERTIES;
956 ret = storvsc_execute_vstor_op(device, request, true);
957 if (ret != 0)
958 return ret;
959
960
961
962
963
964
965 max_chns = vstor_packet->storage_channel_properties.max_channel_cnt;
966
967
968
969
970
971
972
973
974
975
976 stor_device->stor_chns = kcalloc(num_possible_cpus(), sizeof(void *),
977 GFP_KERNEL);
978 if (stor_device->stor_chns == NULL)
979 return -ENOMEM;
980
981 device->channel->change_target_cpu_callback = storvsc_change_target_cpu;
982
983 stor_device->stor_chns[device->channel->target_cpu] = device->channel;
984 cpumask_set_cpu(device->channel->target_cpu,
985 &stor_device->alloced_cpus);
986
987 if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN8) {
988 if (vstor_packet->storage_channel_properties.flags &
989 STORAGE_CHANNEL_SUPPORTS_MULTI_CHANNEL)
990 process_sub_channels = true;
991 }
992 stor_device->max_transfer_bytes =
993 vstor_packet->storage_channel_properties.max_transfer_bytes;
994
995 if (!is_fc)
996 goto done;
997
998
999
1000
1001 memset(vstor_packet, 0, sizeof(struct vstor_packet));
1002 vstor_packet->operation = VSTOR_OPERATION_FCHBA_DATA;
1003 ret = storvsc_execute_vstor_op(device, request, true);
1004 if (ret != 0)
1005 return ret;
1006
1007
1008
1009
1010 cache_wwn(stor_device, vstor_packet);
1011
1012done:
1013
1014 memset(vstor_packet, 0, sizeof(struct vstor_packet));
1015 vstor_packet->operation = VSTOR_OPERATION_END_INITIALIZATION;
1016 ret = storvsc_execute_vstor_op(device, request, true);
1017 if (ret != 0)
1018 return ret;
1019
1020 if (process_sub_channels)
1021 handle_multichannel_storage(device, max_chns);
1022
1023 return ret;
1024}
1025
1026static void storvsc_handle_error(struct vmscsi_request *vm_srb,
1027 struct scsi_cmnd *scmnd,
1028 struct Scsi_Host *host,
1029 u8 asc, u8 ascq)
1030{
1031 struct storvsc_scan_work *wrk;
1032 void (*process_err_fn)(struct work_struct *work);
1033 struct hv_host_device *host_dev = shost_priv(host);
1034
1035
1036
1037
1038
1039
1040
1041 if (vm_srb->srb_status & SRB_STATUS_INVALID_LUN) {
1042 set_host_byte(scmnd, DID_NO_CONNECT);
1043 process_err_fn = storvsc_remove_lun;
1044 goto do_work;
1045 }
1046
1047 if (vm_srb->srb_status & SRB_STATUS_ABORTED) {
1048 if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID &&
1049
1050 (asc == 0x2a) && (ascq == 0x9)) {
1051 process_err_fn = storvsc_device_scan;
1052
1053
1054
1055 set_host_byte(scmnd, DID_REQUEUE);
1056 goto do_work;
1057 }
1058 }
1059
1060 if (vm_srb->srb_status & SRB_STATUS_ERROR) {
1061
1062
1063
1064
1065 if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID)
1066 return;
1067
1068
1069
1070
1071
1072
1073
1074 switch (scmnd->cmnd[0]) {
1075 case ATA_16:
1076 case ATA_12:
1077 set_host_byte(scmnd, DID_PASSTHROUGH);
1078 break;
1079
1080
1081
1082
1083
1084 case TEST_UNIT_READY:
1085 break;
1086 default:
1087 set_host_byte(scmnd, DID_ERROR);
1088 }
1089 }
1090 return;
1091
1092do_work:
1093
1094
1095
1096 wrk = kmalloc(sizeof(struct storvsc_scan_work), GFP_ATOMIC);
1097 if (!wrk) {
1098 set_host_byte(scmnd, DID_TARGET_FAILURE);
1099 return;
1100 }
1101
1102 wrk->host = host;
1103 wrk->lun = vm_srb->lun;
1104 wrk->tgt_id = vm_srb->target_id;
1105 INIT_WORK(&wrk->work, process_err_fn);
1106 queue_work(host_dev->handle_error_wq, &wrk->work);
1107}
1108
1109
1110static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request,
1111 struct storvsc_device *stor_dev)
1112{
1113 struct scsi_cmnd *scmnd = cmd_request->cmd;
1114 struct scsi_sense_hdr sense_hdr;
1115 struct vmscsi_request *vm_srb;
1116 u32 data_transfer_length;
1117 struct Scsi_Host *host;
1118 u32 payload_sz = cmd_request->payload_sz;
1119 void *payload = cmd_request->payload;
1120 bool sense_ok;
1121
1122 host = stor_dev->host;
1123
1124 vm_srb = &cmd_request->vstor_packet.vm_srb;
1125 data_transfer_length = vm_srb->data_transfer_length;
1126
1127 scmnd->result = vm_srb->scsi_status;
1128
1129 if (scmnd->result) {
1130 sense_ok = scsi_normalize_sense(scmnd->sense_buffer,
1131 SCSI_SENSE_BUFFERSIZE, &sense_hdr);
1132
1133 if (sense_ok && do_logging(STORVSC_LOGGING_WARN))
1134 scsi_print_sense_hdr(scmnd->device, "storvsc",
1135 &sense_hdr);
1136 }
1137
1138 if (vm_srb->srb_status != SRB_STATUS_SUCCESS) {
1139 storvsc_handle_error(vm_srb, scmnd, host, sense_hdr.asc,
1140 sense_hdr.ascq);
1141
1142
1143
1144
1145
1146 if (vm_srb->srb_status != SRB_STATUS_DATA_OVERRUN)
1147 data_transfer_length = 0;
1148 }
1149
1150
1151 if (data_transfer_length > cmd_request->payload->range.len)
1152 data_transfer_length = cmd_request->payload->range.len;
1153
1154 scsi_set_resid(scmnd,
1155 cmd_request->payload->range.len - data_transfer_length);
1156
1157 scmnd->scsi_done(scmnd);
1158
1159 if (payload_sz >
1160 sizeof(struct vmbus_channel_packet_multipage_buffer))
1161 kfree(payload);
1162}
1163
1164static void storvsc_on_io_completion(struct storvsc_device *stor_device,
1165 struct vstor_packet *vstor_packet,
1166 struct storvsc_cmd_request *request)
1167{
1168 struct vstor_packet *stor_pkt;
1169 struct hv_device *device = stor_device->device;
1170
1171 stor_pkt = &request->vstor_packet;
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184 if ((stor_pkt->vm_srb.cdb[0] == INQUIRY) ||
1185 (stor_pkt->vm_srb.cdb[0] == MODE_SENSE)) {
1186 vstor_packet->vm_srb.scsi_status = 0;
1187 vstor_packet->vm_srb.srb_status = SRB_STATUS_SUCCESS;
1188 }
1189
1190
1191 stor_pkt->vm_srb.scsi_status = vstor_packet->vm_srb.scsi_status;
1192 stor_pkt->vm_srb.srb_status = vstor_packet->vm_srb.srb_status;
1193
1194
1195
1196
1197
1198 stor_pkt->vm_srb.sense_info_length = min_t(u8, sense_buffer_size,
1199 vstor_packet->vm_srb.sense_info_length);
1200
1201 if (vstor_packet->vm_srb.scsi_status != 0 ||
1202 vstor_packet->vm_srb.srb_status != SRB_STATUS_SUCCESS) {
1203
1204
1205
1206
1207
1208
1209 int loglevel = (stor_pkt->vm_srb.cdb[0] == TEST_UNIT_READY) ?
1210 STORVSC_LOGGING_WARN : STORVSC_LOGGING_ERROR;
1211
1212 storvsc_log(device, loglevel,
1213 "tag#%d cmd 0x%x status: scsi 0x%x srb 0x%x hv 0x%x\n",
1214 request->cmd->request->tag,
1215 stor_pkt->vm_srb.cdb[0],
1216 vstor_packet->vm_srb.scsi_status,
1217 vstor_packet->vm_srb.srb_status,
1218 vstor_packet->status);
1219 }
1220
1221 if (vstor_packet->vm_srb.scsi_status == SAM_STAT_CHECK_CONDITION &&
1222 (vstor_packet->vm_srb.srb_status & SRB_STATUS_AUTOSENSE_VALID))
1223 memcpy(request->cmd->sense_buffer,
1224 vstor_packet->vm_srb.sense_data,
1225 stor_pkt->vm_srb.sense_info_length);
1226
1227 stor_pkt->vm_srb.data_transfer_length =
1228 vstor_packet->vm_srb.data_transfer_length;
1229
1230 storvsc_command_completion(request, stor_device);
1231
1232 if (atomic_dec_and_test(&stor_device->num_outstanding_req) &&
1233 stor_device->drain_notify)
1234 wake_up(&stor_device->waiting_to_drain);
1235}
1236
1237static void storvsc_on_receive(struct storvsc_device *stor_device,
1238 struct vstor_packet *vstor_packet,
1239 struct storvsc_cmd_request *request)
1240{
1241 struct hv_host_device *host_dev;
1242 switch (vstor_packet->operation) {
1243 case VSTOR_OPERATION_COMPLETE_IO:
1244 storvsc_on_io_completion(stor_device, vstor_packet, request);
1245 break;
1246
1247 case VSTOR_OPERATION_REMOVE_DEVICE:
1248 case VSTOR_OPERATION_ENUMERATE_BUS:
1249 host_dev = shost_priv(stor_device->host);
1250 queue_work(
1251 host_dev->handle_error_wq, &host_dev->host_scan_work);
1252 break;
1253
1254 case VSTOR_OPERATION_FCHBA_DATA:
1255 cache_wwn(stor_device, vstor_packet);
1256#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1257 fc_host_node_name(stor_device->host) = stor_device->node_name;
1258 fc_host_port_name(stor_device->host) = stor_device->port_name;
1259#endif
1260 break;
1261 default:
1262 break;
1263 }
1264}
1265
1266static void storvsc_on_channel_callback(void *context)
1267{
1268 struct vmbus_channel *channel = (struct vmbus_channel *)context;
1269 const struct vmpacket_descriptor *desc;
1270 struct hv_device *device;
1271 struct storvsc_device *stor_device;
1272 struct Scsi_Host *shost;
1273
1274 if (channel->primary_channel != NULL)
1275 device = channel->primary_channel->device_obj;
1276 else
1277 device = channel->device_obj;
1278
1279 stor_device = get_in_stor_device(device);
1280 if (!stor_device)
1281 return;
1282
1283 shost = stor_device->host;
1284
1285 foreach_vmbus_pkt(desc, channel) {
1286 struct vstor_packet *packet = hv_pkt_data(desc);
1287 struct storvsc_cmd_request *request = NULL;
1288 u64 rqst_id = desc->trans_id;
1289
1290 if (hv_pkt_datalen(desc) < sizeof(struct vstor_packet) -
1291 stor_device->vmscsi_size_delta) {
1292 dev_err(&device->device, "Invalid packet len\n");
1293 continue;
1294 }
1295
1296 if (rqst_id == VMBUS_RQST_INIT) {
1297 request = &stor_device->init_request;
1298 } else if (rqst_id == VMBUS_RQST_RESET) {
1299 request = &stor_device->reset_request;
1300 } else {
1301
1302 if (rqst_id == 0) {
1303
1304
1305
1306
1307
1308
1309
1310
1311 if (packet->operation == VSTOR_OPERATION_COMPLETE_IO) {
1312 dev_err(&device->device, "Invalid packet with ID of 0\n");
1313 continue;
1314 }
1315 } else {
1316 struct scsi_cmnd *scmnd;
1317
1318
1319 scmnd = scsi_host_find_tag(shost, rqst_id - 1);
1320 if (scmnd == NULL) {
1321 dev_err(&device->device, "Incorrect transaction ID\n");
1322 continue;
1323 }
1324 request = (struct storvsc_cmd_request *)scsi_cmd_priv(scmnd);
1325 }
1326
1327 storvsc_on_receive(stor_device, packet, request);
1328 continue;
1329 }
1330
1331 memcpy(&request->vstor_packet, packet,
1332 (sizeof(struct vstor_packet) - stor_device->vmscsi_size_delta));
1333 complete(&request->wait_event);
1334 }
1335}
1336
1337static int storvsc_connect_to_vsp(struct hv_device *device, u32 ring_size,
1338 bool is_fc)
1339{
1340 struct vmstorage_channel_properties props;
1341 int ret;
1342
1343 memset(&props, 0, sizeof(struct vmstorage_channel_properties));
1344
1345 device->channel->max_pkt_size = STORVSC_MAX_PKT_SIZE;
1346 device->channel->next_request_id_callback = storvsc_next_request_id;
1347
1348 ret = vmbus_open(device->channel,
1349 ring_size,
1350 ring_size,
1351 (void *)&props,
1352 sizeof(struct vmstorage_channel_properties),
1353 storvsc_on_channel_callback, device->channel);
1354
1355 if (ret != 0)
1356 return ret;
1357
1358 ret = storvsc_channel_init(device, is_fc);
1359
1360 return ret;
1361}
1362
1363static int storvsc_dev_remove(struct hv_device *device)
1364{
1365 struct storvsc_device *stor_device;
1366
1367 stor_device = hv_get_drvdata(device);
1368
1369 stor_device->destroy = true;
1370
1371
1372 wmb();
1373
1374
1375
1376
1377
1378
1379
1380 storvsc_wait_to_drain(stor_device);
1381
1382
1383
1384
1385
1386
1387
1388
1389 hv_set_drvdata(device, NULL);
1390
1391
1392 vmbus_close(device->channel);
1393
1394 kfree(stor_device->stor_chns);
1395 kfree(stor_device);
1396 return 0;
1397}
1398
1399static struct vmbus_channel *get_og_chn(struct storvsc_device *stor_device,
1400 u16 q_num)
1401{
1402 u16 slot = 0;
1403 u16 hash_qnum;
1404 const struct cpumask *node_mask;
1405 int num_channels, tgt_cpu;
1406
1407 if (stor_device->num_sc == 0) {
1408 stor_device->stor_chns[q_num] = stor_device->device->channel;
1409 return stor_device->device->channel;
1410 }
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421 node_mask = cpumask_of_node(cpu_to_node(q_num));
1422
1423 num_channels = 0;
1424 for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
1425 if (cpumask_test_cpu(tgt_cpu, node_mask))
1426 num_channels++;
1427 }
1428 if (num_channels == 0) {
1429 stor_device->stor_chns[q_num] = stor_device->device->channel;
1430 return stor_device->device->channel;
1431 }
1432
1433 hash_qnum = q_num;
1434 while (hash_qnum >= num_channels)
1435 hash_qnum -= num_channels;
1436
1437 for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
1438 if (!cpumask_test_cpu(tgt_cpu, node_mask))
1439 continue;
1440 if (slot == hash_qnum)
1441 break;
1442 slot++;
1443 }
1444
1445 stor_device->stor_chns[q_num] = stor_device->stor_chns[tgt_cpu];
1446
1447 return stor_device->stor_chns[q_num];
1448}
1449
1450
1451static int storvsc_do_io(struct hv_device *device,
1452 struct storvsc_cmd_request *request, u16 q_num)
1453{
1454 struct storvsc_device *stor_device;
1455 struct vstor_packet *vstor_packet;
1456 struct vmbus_channel *outgoing_channel, *channel;
1457 unsigned long flags;
1458 int ret = 0;
1459 const struct cpumask *node_mask;
1460 int tgt_cpu;
1461
1462 vstor_packet = &request->vstor_packet;
1463 stor_device = get_out_stor_device(device);
1464
1465 if (!stor_device)
1466 return -ENODEV;
1467
1468
1469 request->device = device;
1470
1471
1472
1473
1474 outgoing_channel = READ_ONCE(stor_device->stor_chns[q_num]);
1475 if (outgoing_channel != NULL) {
1476 if (outgoing_channel->target_cpu == q_num) {
1477
1478
1479
1480
1481 node_mask = cpumask_of_node(cpu_to_node(q_num));
1482 for_each_cpu_wrap(tgt_cpu,
1483 &stor_device->alloced_cpus, q_num + 1) {
1484 if (!cpumask_test_cpu(tgt_cpu, node_mask))
1485 continue;
1486 if (tgt_cpu == q_num)
1487 continue;
1488 channel = READ_ONCE(
1489 stor_device->stor_chns[tgt_cpu]);
1490 if (channel == NULL)
1491 continue;
1492 if (hv_get_avail_to_write_percent(
1493 &channel->outbound)
1494 > ring_avail_percent_lowater) {
1495 outgoing_channel = channel;
1496 goto found_channel;
1497 }
1498 }
1499
1500
1501
1502
1503
1504 if (hv_get_avail_to_write_percent(
1505 &outgoing_channel->outbound)
1506 > ring_avail_percent_lowater)
1507 goto found_channel;
1508
1509
1510
1511
1512
1513
1514 for_each_cpu(tgt_cpu, &stor_device->alloced_cpus) {
1515 if (cpumask_test_cpu(tgt_cpu, node_mask))
1516 continue;
1517 channel = READ_ONCE(
1518 stor_device->stor_chns[tgt_cpu]);
1519 if (channel == NULL)
1520 continue;
1521 if (hv_get_avail_to_write_percent(
1522 &channel->outbound)
1523 > ring_avail_percent_lowater) {
1524 outgoing_channel = channel;
1525 goto found_channel;
1526 }
1527 }
1528 }
1529 } else {
1530 spin_lock_irqsave(&stor_device->lock, flags);
1531 outgoing_channel = stor_device->stor_chns[q_num];
1532 if (outgoing_channel != NULL) {
1533 spin_unlock_irqrestore(&stor_device->lock, flags);
1534 goto found_channel;
1535 }
1536 outgoing_channel = get_og_chn(stor_device, q_num);
1537 spin_unlock_irqrestore(&stor_device->lock, flags);
1538 }
1539
1540found_channel:
1541 vstor_packet->flags |= REQUEST_COMPLETION_FLAG;
1542
1543 vstor_packet->vm_srb.length = (sizeof(struct vmscsi_request) -
1544 stor_device->vmscsi_size_delta);
1545
1546
1547 vstor_packet->vm_srb.sense_info_length = sense_buffer_size;
1548
1549
1550 vstor_packet->vm_srb.data_transfer_length =
1551 request->payload->range.len;
1552
1553 vstor_packet->operation = VSTOR_OPERATION_EXECUTE_SRB;
1554
1555 if (request->payload->range.len) {
1556
1557 ret = vmbus_sendpacket_mpb_desc(outgoing_channel,
1558 request->payload, request->payload_sz,
1559 vstor_packet,
1560 (sizeof(struct vstor_packet) -
1561 stor_device->vmscsi_size_delta),
1562 (unsigned long)request);
1563 } else {
1564 ret = vmbus_sendpacket(outgoing_channel, vstor_packet,
1565 (sizeof(struct vstor_packet) -
1566 stor_device->vmscsi_size_delta),
1567 (unsigned long)request,
1568 VM_PKT_DATA_INBAND,
1569 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1570 }
1571
1572 if (ret != 0)
1573 return ret;
1574
1575 atomic_inc(&stor_device->num_outstanding_req);
1576
1577 return ret;
1578}
1579
1580static int storvsc_device_alloc(struct scsi_device *sdevice)
1581{
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591 sdevice->sdev_bflags = BLIST_REPORTLUN2 | BLIST_TRY_VPD_PAGES;
1592
1593 return 0;
1594}
1595
1596static int storvsc_device_configure(struct scsi_device *sdevice)
1597{
1598 blk_queue_rq_timeout(sdevice->request_queue, (storvsc_timeout * HZ));
1599
1600
1601 blk_queue_virt_boundary(sdevice->request_queue, PAGE_SIZE - 1);
1602
1603 sdevice->no_write_same = 1;
1604
1605
1606
1607
1608
1609
1610 if (!strncmp(sdevice->vendor, "Msft", 4)) {
1611 switch (vmstor_proto_version) {
1612 case VMSTOR_PROTO_VERSION_WIN8:
1613 case VMSTOR_PROTO_VERSION_WIN8_1:
1614 sdevice->scsi_level = SCSI_SPC_3;
1615 break;
1616 }
1617
1618 if (vmstor_proto_version >= VMSTOR_PROTO_VERSION_WIN10)
1619 sdevice->no_write_same = 0;
1620 }
1621
1622 return 0;
1623}
1624
1625static int storvsc_get_chs(struct scsi_device *sdev, struct block_device * bdev,
1626 sector_t capacity, int *info)
1627{
1628 sector_t nsect = capacity;
1629 sector_t cylinders = nsect;
1630 int heads, sectors_pt;
1631
1632
1633
1634
1635 heads = 0xff;
1636 sectors_pt = 0x3f;
1637 sector_div(cylinders, heads * sectors_pt);
1638 if ((sector_t)(cylinders + 1) * heads * sectors_pt < nsect)
1639 cylinders = 0xffff;
1640
1641 info[0] = heads;
1642 info[1] = sectors_pt;
1643 info[2] = (int)cylinders;
1644
1645 return 0;
1646}
1647
1648static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
1649{
1650 struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
1651 struct hv_device *device = host_dev->dev;
1652
1653 struct storvsc_device *stor_device;
1654 struct storvsc_cmd_request *request;
1655 struct vstor_packet *vstor_packet;
1656 int ret, t;
1657
1658 stor_device = get_out_stor_device(device);
1659 if (!stor_device)
1660 return FAILED;
1661
1662 request = &stor_device->reset_request;
1663 vstor_packet = &request->vstor_packet;
1664 memset(vstor_packet, 0, sizeof(struct vstor_packet));
1665
1666 init_completion(&request->wait_event);
1667
1668 vstor_packet->operation = VSTOR_OPERATION_RESET_BUS;
1669 vstor_packet->flags = REQUEST_COMPLETION_FLAG;
1670 vstor_packet->vm_srb.path_id = stor_device->path_id;
1671
1672 ret = vmbus_sendpacket(device->channel, vstor_packet,
1673 (sizeof(struct vstor_packet) -
1674 stor_device->vmscsi_size_delta),
1675 VMBUS_RQST_RESET,
1676 VM_PKT_DATA_INBAND,
1677 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1678 if (ret != 0)
1679 return FAILED;
1680
1681 t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
1682 if (t == 0)
1683 return TIMEOUT_ERROR;
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694 storvsc_wait_to_drain(stor_device);
1695
1696 return SUCCESS;
1697}
1698
1699
1700
1701
1702
1703
1704static enum blk_eh_timer_return storvsc_eh_timed_out(struct scsi_cmnd *scmnd)
1705{
1706#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
1707 if (scmnd->device->host->transportt == fc_transport_template)
1708 return fc_eh_timed_out(scmnd);
1709#endif
1710 return BLK_EH_RESET_TIMER;
1711}
1712
1713static bool storvsc_scsi_cmd_ok(struct scsi_cmnd *scmnd)
1714{
1715 bool allowed = true;
1716 u8 scsi_op = scmnd->cmnd[0];
1717
1718 switch (scsi_op) {
1719
1720 case WRITE_SAME:
1721
1722
1723
1724
1725 case SET_WINDOW:
1726 set_host_byte(scmnd, DID_ERROR);
1727 allowed = false;
1728 break;
1729 default:
1730 break;
1731 }
1732 return allowed;
1733}
1734
1735static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
1736{
1737 int ret;
1738 struct hv_host_device *host_dev = shost_priv(host);
1739 struct hv_device *dev = host_dev->dev;
1740 struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd);
1741 int i;
1742 struct scatterlist *sgl;
1743 unsigned int sg_count;
1744 struct vmscsi_request *vm_srb;
1745 struct vmbus_packet_mpb_array *payload;
1746 u32 payload_sz;
1747 u32 length;
1748
1749 if (vmstor_proto_version <= VMSTOR_PROTO_VERSION_WIN8) {
1750
1751
1752
1753
1754
1755
1756
1757
1758 if (!storvsc_scsi_cmd_ok(scmnd)) {
1759 scmnd->scsi_done(scmnd);
1760 return 0;
1761 }
1762 }
1763
1764
1765 cmd_request->cmd = scmnd;
1766
1767 memset(&cmd_request->vstor_packet, 0, sizeof(struct vstor_packet));
1768 vm_srb = &cmd_request->vstor_packet.vm_srb;
1769 vm_srb->win8_extension.time_out_value = 60;
1770
1771 vm_srb->win8_extension.srb_flags |=
1772 SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
1773
1774 if (scmnd->device->tagged_supported) {
1775 vm_srb->win8_extension.srb_flags |=
1776 (SRB_FLAGS_QUEUE_ACTION_ENABLE | SRB_FLAGS_NO_QUEUE_FREEZE);
1777 vm_srb->win8_extension.queue_tag = SP_UNTAGGED;
1778 vm_srb->win8_extension.queue_action = SRB_SIMPLE_TAG_REQUEST;
1779 }
1780
1781
1782 switch (scmnd->sc_data_direction) {
1783 case DMA_TO_DEVICE:
1784 vm_srb->data_in = WRITE_TYPE;
1785 vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_OUT;
1786 break;
1787 case DMA_FROM_DEVICE:
1788 vm_srb->data_in = READ_TYPE;
1789 vm_srb->win8_extension.srb_flags |= SRB_FLAGS_DATA_IN;
1790 break;
1791 case DMA_NONE:
1792 vm_srb->data_in = UNKNOWN_TYPE;
1793 vm_srb->win8_extension.srb_flags |= SRB_FLAGS_NO_DATA_TRANSFER;
1794 break;
1795 default:
1796
1797
1798
1799
1800 WARN(1, "Unexpected data direction: %d\n",
1801 scmnd->sc_data_direction);
1802 return -EINVAL;
1803 }
1804
1805
1806 vm_srb->port_number = host_dev->port;
1807 vm_srb->path_id = scmnd->device->channel;
1808 vm_srb->target_id = scmnd->device->id;
1809 vm_srb->lun = scmnd->device->lun;
1810
1811 vm_srb->cdb_length = scmnd->cmd_len;
1812
1813 memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length);
1814
1815 sgl = (struct scatterlist *)scsi_sglist(scmnd);
1816 sg_count = scsi_sg_count(scmnd);
1817
1818 length = scsi_bufflen(scmnd);
1819 payload = (struct vmbus_packet_mpb_array *)&cmd_request->mpb;
1820 payload_sz = sizeof(cmd_request->mpb);
1821
1822 if (sg_count) {
1823 unsigned int hvpgoff, hvpfns_to_add;
1824 unsigned long offset_in_hvpg = offset_in_hvpage(sgl->offset);
1825 unsigned int hvpg_count = HVPFN_UP(offset_in_hvpg + length);
1826 u64 hvpfn;
1827
1828 if (hvpg_count > MAX_PAGE_BUFFER_COUNT) {
1829
1830 payload_sz = (hvpg_count * sizeof(u64) +
1831 sizeof(struct vmbus_packet_mpb_array));
1832 payload = kzalloc(payload_sz, GFP_ATOMIC);
1833 if (!payload)
1834 return SCSI_MLQUEUE_DEVICE_BUSY;
1835 }
1836
1837 payload->range.len = length;
1838 payload->range.offset = offset_in_hvpg;
1839
1840
1841 for (i = 0; sgl != NULL; sgl = sg_next(sgl)) {
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851 hvpgoff = HVPFN_DOWN(sgl->offset);
1852 hvpfn = page_to_hvpfn(sg_page(sgl)) + hvpgoff;
1853 hvpfns_to_add = HVPFN_UP(sgl->offset + sgl->length) -
1854 hvpgoff;
1855
1856
1857
1858
1859
1860
1861
1862
1863 while (hvpfns_to_add--)
1864 payload->range.pfn_array[i++] = hvpfn++;
1865 }
1866 }
1867
1868 cmd_request->payload = payload;
1869 cmd_request->payload_sz = payload_sz;
1870
1871
1872 ret = storvsc_do_io(dev, cmd_request, get_cpu());
1873 put_cpu();
1874
1875 if (ret == -EAGAIN) {
1876 if (payload_sz > sizeof(cmd_request->mpb))
1877 kfree(payload);
1878
1879 return SCSI_MLQUEUE_DEVICE_BUSY;
1880 }
1881
1882 return 0;
1883}
1884
1885static struct scsi_host_template scsi_driver = {
1886 .module = THIS_MODULE,
1887 .name = "storvsc_host_t",
1888 .cmd_size = sizeof(struct storvsc_cmd_request),
1889 .bios_param = storvsc_get_chs,
1890 .queuecommand = storvsc_queuecommand,
1891 .eh_host_reset_handler = storvsc_host_reset_handler,
1892 .proc_name = "storvsc_host",
1893 .eh_timed_out = storvsc_eh_timed_out,
1894 .slave_alloc = storvsc_device_alloc,
1895 .slave_configure = storvsc_device_configure,
1896 .cmd_per_lun = 2048,
1897 .this_id = -1,
1898 .use_clustering = ENABLE_CLUSTERING,
1899 .no_write_same = 1,
1900 .track_queue_depth = 1,
1901 .change_queue_depth = storvsc_change_queue_depth,
1902};
1903
1904enum {
1905 SCSI_GUID,
1906 IDE_GUID,
1907 SFC_GUID,
1908};
1909
1910static const struct hv_vmbus_device_id id_table[] = {
1911
1912 { HV_SCSI_GUID,
1913 .driver_data = SCSI_GUID
1914 },
1915
1916 { HV_IDE_GUID,
1917 .driver_data = IDE_GUID
1918 },
1919
1920 {
1921 HV_SYNTHFC_GUID,
1922 .driver_data = SFC_GUID
1923 },
1924 { },
1925};
1926
1927MODULE_DEVICE_TABLE(vmbus, id_table);
1928
1929static const struct { guid_t guid; } fc_guid = { HV_SYNTHFC_GUID };
1930
1931static bool hv_dev_is_fc(struct hv_device *hv_dev)
1932{
1933 return guid_equal(&fc_guid.guid, &hv_dev->dev_type);
1934}
1935
1936static int storvsc_probe(struct hv_device *device,
1937 const struct hv_vmbus_device_id *dev_id)
1938{
1939 int ret;
1940 int num_cpus = num_online_cpus();
1941 int num_present_cpus = num_present_cpus();
1942 struct Scsi_Host *host;
1943 struct hv_host_device *host_dev;
1944 bool dev_is_ide = ((dev_id->driver_data == IDE_GUID) ? true : false);
1945 bool is_fc = ((dev_id->driver_data == SFC_GUID) ? true : false);
1946 int target = 0;
1947 struct storvsc_device *stor_device;
1948 int max_luns_per_target;
1949 int max_targets;
1950 int max_channels;
1951 int max_sub_channels = 0;
1952
1953
1954
1955
1956
1957
1958 if (vmbus_proto_version < VERSION_WIN8) {
1959 max_luns_per_target = STORVSC_IDE_MAX_LUNS_PER_TARGET;
1960 max_targets = STORVSC_IDE_MAX_TARGETS;
1961 max_channels = STORVSC_IDE_MAX_CHANNELS;
1962 } else {
1963 max_luns_per_target = STORVSC_MAX_LUNS_PER_TARGET;
1964 max_targets = STORVSC_MAX_TARGETS;
1965 max_channels = STORVSC_MAX_CHANNELS;
1966
1967
1968
1969
1970
1971
1972 if (!dev_is_ide)
1973 max_sub_channels =
1974 (num_cpus - 1) / storvsc_vcpus_per_sub_channel;
1975 }
1976
1977 scsi_driver.can_queue = max_outstanding_req_per_channel *
1978 (max_sub_channels + 1) *
1979 (100 - ring_avail_percent_lowater) / 100;
1980
1981 host = scsi_host_alloc(&scsi_driver,
1982 sizeof(struct hv_host_device));
1983 if (!host)
1984 return -ENOMEM;
1985
1986 host_dev = shost_priv(host);
1987 memset(host_dev, 0, sizeof(struct hv_host_device));
1988
1989 host_dev->port = host->host_no;
1990 host_dev->dev = device;
1991 host_dev->host = host;
1992
1993
1994 stor_device = kzalloc(sizeof(struct storvsc_device), GFP_KERNEL);
1995 if (!stor_device) {
1996 ret = -ENOMEM;
1997 goto err_out0;
1998 }
1999
2000 stor_device->destroy = false;
2001 init_waitqueue_head(&stor_device->waiting_to_drain);
2002 stor_device->device = device;
2003 stor_device->host = host;
2004 stor_device->vmscsi_size_delta = sizeof(struct vmscsi_win8_extension);
2005 spin_lock_init(&stor_device->lock);
2006 hv_set_drvdata(device, stor_device);
2007
2008 stor_device->port_number = host->host_no;
2009 ret = storvsc_connect_to_vsp(device, storvsc_ringbuffer_size, is_fc);
2010 if (ret)
2011 goto err_out1;
2012
2013 host_dev->path = stor_device->path_id;
2014 host_dev->target = stor_device->target_id;
2015
2016 switch (dev_id->driver_data) {
2017 case SFC_GUID:
2018 host->max_lun = STORVSC_FC_MAX_LUNS_PER_TARGET;
2019 host->max_id = STORVSC_FC_MAX_TARGETS;
2020 host->max_channel = STORVSC_FC_MAX_CHANNELS - 1;
2021#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
2022 host->transportt = fc_transport_template;
2023#endif
2024 break;
2025
2026 case SCSI_GUID:
2027 host->max_lun = max_luns_per_target;
2028 host->max_id = max_targets;
2029 host->max_channel = max_channels - 1;
2030 break;
2031
2032 default:
2033 host->max_lun = STORVSC_IDE_MAX_LUNS_PER_TARGET;
2034 host->max_id = STORVSC_IDE_MAX_TARGETS;
2035 host->max_channel = STORVSC_IDE_MAX_CHANNELS - 1;
2036 break;
2037 }
2038
2039 host->max_cmd_len = STORVSC_MAX_CMD_LEN;
2040
2041
2042
2043
2044
2045 host->sg_tablesize = (stor_device->max_transfer_bytes >> PAGE_SHIFT);
2046
2047
2048
2049
2050 if (!dev_is_ide) {
2051 if (storvsc_max_hw_queues > num_present_cpus) {
2052 storvsc_max_hw_queues = 0;
2053 storvsc_log(device, STORVSC_LOGGING_WARN,
2054 "Resetting invalid storvsc_max_hw_queues value to default.\n");
2055 }
2056 if (storvsc_max_hw_queues)
2057 host->nr_hw_queues = storvsc_max_hw_queues;
2058 else
2059 host->nr_hw_queues = num_present_cpus;
2060 }
2061
2062
2063
2064
2065 host_dev->handle_error_wq =
2066 alloc_ordered_workqueue("storvsc_error_wq_%d",
2067 WQ_MEM_RECLAIM,
2068 host->host_no);
2069 if (!host_dev->handle_error_wq) {
2070 ret = -ENOMEM;
2071 goto err_out2;
2072 }
2073 INIT_WORK(&host_dev->host_scan_work, storvsc_host_scan);
2074
2075 ret = scsi_add_host(host, &device->device);
2076 if (ret != 0)
2077 goto err_out3;
2078
2079 if (!dev_is_ide) {
2080 scsi_scan_host(host);
2081 } else {
2082 target = (device->dev_instance.b[5] << 8 |
2083 device->dev_instance.b[4]);
2084 ret = scsi_add_device(host, 0, target, 0);
2085 if (ret)
2086 goto err_out4;
2087 }
2088#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
2089 if (host->transportt == fc_transport_template) {
2090 struct fc_rport_identifiers ids = {
2091 .roles = FC_PORT_ROLE_FCP_DUMMY_INITIATOR,
2092 };
2093
2094 fc_host_node_name(host) = stor_device->node_name;
2095 fc_host_port_name(host) = stor_device->port_name;
2096 stor_device->rport = fc_remote_port_add(host, 0, &ids);
2097 if (!stor_device->rport) {
2098 ret = -ENOMEM;
2099 goto err_out4;
2100 }
2101 }
2102#endif
2103 return 0;
2104
2105err_out4:
2106 scsi_remove_host(host);
2107
2108err_out3:
2109 destroy_workqueue(host_dev->handle_error_wq);
2110
2111err_out2:
2112
2113
2114
2115
2116
2117
2118 storvsc_dev_remove(device);
2119 goto err_out0;
2120
2121err_out1:
2122 kfree(stor_device->stor_chns);
2123 kfree(stor_device);
2124
2125err_out0:
2126 scsi_host_put(host);
2127 return ret;
2128}
2129
2130
2131static int storvsc_change_queue_depth(struct scsi_device *sdev, int queue_depth)
2132{
2133 if (queue_depth > scsi_driver.can_queue)
2134 queue_depth = scsi_driver.can_queue;
2135
2136 return scsi_change_queue_depth(sdev, queue_depth);
2137}
2138
2139static int storvsc_remove(struct hv_device *dev)
2140{
2141 struct storvsc_device *stor_device = hv_get_drvdata(dev);
2142 struct Scsi_Host *host = stor_device->host;
2143 struct hv_host_device *host_dev = shost_priv(host);
2144
2145#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
2146 if (host->transportt == fc_transport_template) {
2147 fc_remote_port_delete(stor_device->rport);
2148 fc_remove_host(host);
2149 }
2150#endif
2151 destroy_workqueue(host_dev->handle_error_wq);
2152 scsi_remove_host(host);
2153 storvsc_dev_remove(dev);
2154 scsi_host_put(host);
2155
2156 return 0;
2157}
2158
2159static int storvsc_suspend(struct hv_device *hv_dev)
2160{
2161 struct storvsc_device *stor_device = hv_get_drvdata(hv_dev);
2162 struct Scsi_Host *host = stor_device->host;
2163 struct hv_host_device *host_dev = shost_priv(host);
2164
2165 storvsc_wait_to_drain(stor_device);
2166
2167 drain_workqueue(host_dev->handle_error_wq);
2168
2169 vmbus_close(hv_dev->channel);
2170
2171 kfree(stor_device->stor_chns);
2172 stor_device->stor_chns = NULL;
2173
2174 cpumask_clear(&stor_device->alloced_cpus);
2175
2176 return 0;
2177}
2178
2179static int storvsc_resume(struct hv_device *hv_dev)
2180{
2181 int ret;
2182
2183 ret = storvsc_connect_to_vsp(hv_dev, storvsc_ringbuffer_size,
2184 hv_dev_is_fc(hv_dev));
2185 return ret;
2186}
2187
2188static struct hv_driver storvsc_drv = {
2189 .name = KBUILD_MODNAME,
2190 .id_table = id_table,
2191 .probe = storvsc_probe,
2192 .remove = storvsc_remove,
2193 .suspend = storvsc_suspend,
2194 .resume = storvsc_resume,
2195 .driver = {
2196 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
2197 },
2198};
2199
2200#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
2201static struct fc_function_template fc_transport_functions = {
2202 .show_host_node_name = 1,
2203 .show_host_port_name = 1,
2204};
2205#endif
2206
2207static int __init storvsc_drv_init(void)
2208{
2209 int ret;
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221 max_outstanding_req_per_channel =
2222 ((storvsc_ringbuffer_size - PAGE_SIZE) /
2223 ALIGN(MAX_MULTIPAGE_BUFFER_PACKET +
2224 sizeof(struct vstor_packet) + sizeof(u64),
2225 sizeof(u64)));
2226
2227#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
2228 fc_transport_template = fc_attach_transport(&fc_transport_functions);
2229 if (!fc_transport_template)
2230 return -ENODEV;
2231#endif
2232
2233 ret = vmbus_driver_register(&storvsc_drv);
2234
2235#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
2236 if (ret)
2237 fc_release_transport(fc_transport_template);
2238#endif
2239
2240 return ret;
2241}
2242
2243static void __exit storvsc_drv_exit(void)
2244{
2245 vmbus_driver_unregister(&storvsc_drv);
2246#if IS_ENABLED(CONFIG_SCSI_FC_ATTRS)
2247 fc_release_transport(fc_transport_template);
2248#endif
2249}
2250
2251MODULE_LICENSE("GPL");
2252MODULE_DESCRIPTION("Microsoft Hyper-V virtual storage driver");
2253module_init(storvsc_drv_init);
2254module_exit(storvsc_drv_exit);
2255