scsi: storvsc: Use blk_mq_unique_tag() to generate requestIDs

Use blk_mq_unique_tag() to generate requestIDs for StorVSC, avoiding
all issues with allocating enough entries in the VMbus requestor.

Suggested-by: Michael Kelley <mikelley@microsoft.com>
Signed-off-by: Andrea Parri (Microsoft) <parri.andrea@gmail.com>
Reviewed-by: Michael Kelley <mikelley@microsoft.com>
Acked-by: Martin K. Petersen <martin.petersen@oracle.com>
Link: https://lore.kernel.org/r/20210510210841.370472-1-parri.andrea@gmail.com
Signed-off-by: Wei Liu <wei.liu@kernel.org>

diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
index bfbca4eeb77336cb3ebbf049bddfbb81d969220a..f3761c73b074256c69fd5d57389d98830fb83af3 100644 (file)
--- a/drivers/hv/channel.c
+++ b/drivers/hv/channel.c
@@ -1189,15 +1189,14 @@ EXPORT_SYMBOL_GPL(vmbus_recvpacket_raw);
  * vmbus_next_request_id - Returns a new request id. It is also
  * the index at which the guest memory address is stored.
  * Uses a spin lock to avoid race conditions.
- * @rqstor: Pointer to the requestor struct
+ * @channel: Pointer to the VMbus channel struct
  * @rqst_add: Guest memory address to be stored in the array
  */
-u64 vmbus_next_request_id(struct vmbus_requestor *rqstor, u64 rqst_addr)
+u64 vmbus_next_request_id(struct vmbus_channel *channel, u64 rqst_addr)
 {
+       struct vmbus_requestor *rqstor = &channel->requestor;
        unsigned long flags;
        u64 current_id;
-       const struct vmbus_channel *channel =
-               container_of(rqstor, const struct vmbus_channel, requestor);
 
        /* Check rqstor has been initialized */
        if (!channel->rqstor_size)
@@ -1231,16 +1230,15 @@ EXPORT_SYMBOL_GPL(vmbus_next_request_id);
 /*
  * vmbus_request_addr - Returns the memory address stored at @trans_id
  * in @rqstor. Uses a spin lock to avoid race conditions.
- * @rqstor: Pointer to the requestor struct
+ * @channel: Pointer to the VMbus channel struct
  * @trans_id: Request id sent back from Hyper-V. Becomes the requestor's
  * next request id.
  */
-u64 vmbus_request_addr(struct vmbus_requestor *rqstor, u64 trans_id)
+u64 vmbus_request_addr(struct vmbus_channel *channel, u64 trans_id)
 {
+       struct vmbus_requestor *rqstor = &channel->requestor;
        unsigned long flags;
        u64 req_addr;
-       const struct vmbus_channel *channel =
-               container_of(rqstor, const struct vmbus_channel, requestor);
 
        /* Check rqstor has been initialized */
        if (!channel->rqstor_size)

diff --git a/drivers/hv/ring_buffer.c b/drivers/hv/ring_buffer.c
index e621f8d9b436e9c9d6618dd32f50fb1567f43906..2aee356840a2b480cb88ef569ef12b2d9da44a59 100644 (file)
--- a/drivers/hv/ring_buffer.c
+++ b/drivers/hv/ring_buffer.c
@@ -312,10 +312,12 @@ int hv_ringbuffer_write(struct vmbus_channel *channel,
         */
 
        if (desc->flags == VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED) {
-               rqst_id = vmbus_next_request_id(&channel->requestor, requestid);
-               if (rqst_id == VMBUS_RQST_ERROR) {
-                       spin_unlock_irqrestore(&outring_info->ring_lock, flags);
-                       return -EAGAIN;
+               if (channel->next_request_id_callback != NULL) {
+                       rqst_id = channel->next_request_id_callback(channel, requestid);
+                       if (rqst_id == VMBUS_RQST_ERROR) {
+                               spin_unlock_irqrestore(&outring_info->ring_lock, flags);
+                               return -EAGAIN;
+                       }
                }
        }
        desc = hv_get_ring_buffer(outring_info) + old_write;
@@ -343,7 +345,8 @@ int hv_ringbuffer_write(struct vmbus_channel *channel,
        if (channel->rescind) {
                if (rqst_id != VMBUS_NO_RQSTOR) {
                        /* Reclaim request ID to avoid leak of IDs */
-                       vmbus_request_addr(&channel->requestor, rqst_id);
+                       if (channel->request_addr_callback != NULL)
+                               channel->request_addr_callback(channel, rqst_id);
                }
                return -ENODEV;
        }

diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c
index 067077138e5298e17163df6d603c74a6b7daa0fd..7bd9354128534e081eeece404d876475d0730a1c 100644 (file)
--- a/drivers/net/hyperv/netvsc.c
+++ b/drivers/net/hyperv/netvsc.c
@@ -757,7 +757,7 @@ static void netvsc_send_tx_complete(struct net_device *ndev,
        int queue_sends;
        u64 cmd_rqst;
 
-       cmd_rqst = vmbus_request_addr(&channel->requestor, (u64)desc->trans_id);
+       cmd_rqst = channel->request_addr_callback(channel, (u64)desc->trans_id);
        if (cmd_rqst == VMBUS_RQST_ERROR) {
                netdev_err(ndev, "Incorrect transaction id\n");
                return;
@@ -817,8 +817,8 @@ static void netvsc_send_completion(struct net_device *ndev,
 
        /* First check if this is a VMBUS completion without data payload */
        if (!msglen) {
-               cmd_rqst = vmbus_request_addr(&incoming_channel->requestor,
-                                             (u64)desc->trans_id);
+               cmd_rqst = incoming_channel->request_addr_callback(incoming_channel,
+                                                                  (u64)desc->trans_id);
                if (cmd_rqst == VMBUS_RQST_ERROR) {
                        netdev_err(ndev, "Invalid transaction id\n");
                        return;
@@ -1649,6 +1649,8 @@ struct netvsc_device *netvsc_device_add(struct hv_device *device,
                       netvsc_poll, NAPI_POLL_WEIGHT);
 
        /* Open the channel */
+       device->channel->next_request_id_callback = vmbus_next_request_id;
+       device->channel->request_addr_callback = vmbus_request_addr;
        device->channel->rqstor_size = netvsc_rqstor_size(netvsc_ring_bytes);
        device->channel->max_pkt_size = NETVSC_MAX_PKT_SIZE;
 

diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index d7ff9ddcbae2806b9c9ffc0a62e85198ab5e6f8f..983bf362466ad65942b861a734f720302e8a7275 100644 (file)
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -1259,6 +1259,8 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
        /* Set the channel before opening.*/
        nvchan->channel = new_sc;
 
+       new_sc->next_request_id_callback = vmbus_next_request_id;
+       new_sc->request_addr_callback = vmbus_request_addr;
        new_sc->rqstor_size = netvsc_rqstor_size(netvsc_ring_bytes);
        new_sc->max_pkt_size = NETVSC_MAX_PKT_SIZE;
 

diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
index 07149fa72b68397d61fb243eb23aefe5554a8cfd..4037539293207a0990e94cf467a89a3664d0666f 100644 (file)
--- a/drivers/scsi/storvsc_drv.c
+++ b/drivers/scsi/storvsc_drv.c
@@ -696,6 +696,23 @@ old_is_alloced:
        spin_unlock_irqrestore(&stor_device->lock, flags);
 }
 
+static u64 storvsc_next_request_id(struct vmbus_channel *channel, u64 rqst_addr)
+{
+       struct storvsc_cmd_request *request =
+               (struct storvsc_cmd_request *)(unsigned long)rqst_addr;
+
+       if (rqst_addr == VMBUS_RQST_INIT)
+               return VMBUS_RQST_INIT;
+       if (rqst_addr == VMBUS_RQST_RESET)
+               return VMBUS_RQST_RESET;
+
+       /*
+        * Cannot return an ID of 0, which is reserved for an unsolicited
+        * message from Hyper-V.
+        */
+       return (u64)blk_mq_unique_tag(request->cmd->request) + 1;
+}
+
 static void handle_sc_creation(struct vmbus_channel *new_sc)
 {
        struct hv_device *device = new_sc->primary_channel->device_obj;
@@ -711,11 +728,7 @@ static void handle_sc_creation(struct vmbus_channel *new_sc)
        memset(&props, 0, sizeof(struct vmstorage_channel_properties));
        new_sc->max_pkt_size = STORVSC_MAX_PKT_SIZE;
 
-       /*
-        * The size of vmbus_requestor is an upper bound on the number of requests
-        * that can be in-progress at any one time across all channels.
-        */
-       new_sc->rqstor_size = scsi_driver.can_queue;
+       new_sc->next_request_id_callback = storvsc_next_request_id;
 
        ret = vmbus_open(new_sc,
                         storvsc_ringbuffer_size,
@@ -782,7 +795,7 @@ static void  handle_multichannel_storage(struct hv_device *device, int max_chns)
        ret = vmbus_sendpacket(device->channel, vstor_packet,
                               (sizeof(struct vstor_packet) -
                               stor_device->vmscsi_size_delta),
-                              (unsigned long)request,
+                              VMBUS_RQST_INIT,
                               VM_PKT_DATA_INBAND,
                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 
@@ -851,7 +864,7 @@ static int storvsc_execute_vstor_op(struct hv_device *device,
        ret = vmbus_sendpacket(device->channel, vstor_packet,
                               (sizeof(struct vstor_packet) -
                               stor_device->vmscsi_size_delta),
-                              (unsigned long)request,
+                              VMBUS_RQST_INIT,
                               VM_PKT_DATA_INBAND,
                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
        if (ret != 0)
@@ -1253,6 +1266,7 @@ static void storvsc_on_channel_callback(void *context)
        const struct vmpacket_descriptor *desc;
        struct hv_device *device;
        struct storvsc_device *stor_device;
+       struct Scsi_Host *shost;
 
        if (channel->primary_channel != NULL)
                device = channel->primary_channel->device_obj;
@@ -1263,20 +1277,12 @@ static void storvsc_on_channel_callback(void *context)
        if (!stor_device)
                return;
 
-       foreach_vmbus_pkt(desc, channel) {
-               void *packet = hv_pkt_data(desc);
-               struct storvsc_cmd_request *request;
-               u64 cmd_rqst;
-
-               cmd_rqst = vmbus_request_addr(&channel->requestor,
-                                             desc->trans_id);
-               if (cmd_rqst == VMBUS_RQST_ERROR) {
-                       dev_err(&device->device,
-                               "Incorrect transaction id\n");
-                       continue;
-               }
+       shost = stor_device->host;
 
-               request = (struct storvsc_cmd_request *)(unsigned long)cmd_rqst;
+       foreach_vmbus_pkt(desc, channel) {
+               struct vstor_packet *packet = hv_pkt_data(desc);
+               struct storvsc_cmd_request *request = NULL;
+               u64 rqst_id = desc->trans_id;
 
                if (hv_pkt_datalen(desc) < sizeof(struct vstor_packet) -
                                stor_device->vmscsi_size_delta) {
@@ -1284,14 +1290,44 @@ static void storvsc_on_channel_callback(void *context)
                        continue;
                }
 
-               if (request == &stor_device->init_request ||
-                   request == &stor_device->reset_request) {
-                       memcpy(&request->vstor_packet, packet,
-                              (sizeof(struct vstor_packet) - stor_device->vmscsi_size_delta));
-                       complete(&request->wait_event);
+               if (rqst_id == VMBUS_RQST_INIT) {
+                       request = &stor_device->init_request;
+               } else if (rqst_id == VMBUS_RQST_RESET) {
+                       request = &stor_device->reset_request;
                } else {
+                       /* Hyper-V can send an unsolicited message with ID of 0 */
+                       if (rqst_id == 0) {
+                               /*
+                                * storvsc_on_receive() looks at the vstor_packet in the message
+                                * from the ring buffer.  If the operation in the vstor_packet is
+                                * COMPLETE_IO, then we call storvsc_on_io_completion(), and
+                                * dereference the guest memory address.  Make sure we don't call
+                                * storvsc_on_io_completion() with a guest memory address that is
+                                * zero if Hyper-V were to construct and send such a bogus packet.
+                                */
+                               if (packet->operation == VSTOR_OPERATION_COMPLETE_IO) {
+                                       dev_err(&device->device, "Invalid packet with ID of 0\n");
+                                       continue;
+                               }
+                       } else {
+                               struct scsi_cmnd *scmnd;
+
+                               /* Transaction 'rqst_id' corresponds to tag 'rqst_id - 1' */
+                               scmnd = scsi_host_find_tag(shost, rqst_id - 1);
+                               if (scmnd == NULL) {
+                                       dev_err(&device->device, "Incorrect transaction ID\n");
+                                       continue;
+                               }
+                               request = (struct storvsc_cmd_request *)scsi_cmd_priv(scmnd);
+                       }
+
                        storvsc_on_receive(stor_device, packet, request);
+                       continue;
                }
+
+               memcpy(&request->vstor_packet, packet,
+                      (sizeof(struct vstor_packet) - stor_device->vmscsi_size_delta));
+               complete(&request->wait_event);
        }
 }
 
@@ -1304,11 +1340,7 @@ static int storvsc_connect_to_vsp(struct hv_device *device, u32 ring_size,
        memset(&props, 0, sizeof(struct vmstorage_channel_properties));
 
        device->channel->max_pkt_size = STORVSC_MAX_PKT_SIZE;
-       /*
-        * The size of vmbus_requestor is an upper bound on the number of requests
-        * that can be in-progress at any one time across all channels.
-        */
-       device->channel->rqstor_size = scsi_driver.can_queue;
+       device->channel->next_request_id_callback = storvsc_next_request_id;
 
        ret = vmbus_open(device->channel,
                         ring_size,
@@ -1634,7 +1666,7 @@ static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
        ret = vmbus_sendpacket(device->channel, vstor_packet,
                               (sizeof(struct vstor_packet) -
                                stor_device->vmscsi_size_delta),
-                              (unsigned long)&stor_device->reset_request,
+                              VMBUS_RQST_RESET,
                               VM_PKT_DATA_INBAND,
                               VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
        if (ret != 0)

diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 3932446f215f202f31ac4969cb4d06ad0517997f..2e859d2f96094bda518f629a194f40c01a0ab8a2 100644 (file)
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -794,7 +794,11 @@ struct vmbus_requestor {
 
 #define VMBUS_NO_RQSTOR U64_MAX
 #define VMBUS_RQST_ERROR (U64_MAX - 1)
+/* NetVSC-specific */
 #define VMBUS_RQST_ID_NO_RESPONSE (U64_MAX - 2)
+/* StorVSC-specific */
+#define VMBUS_RQST_INIT (U64_MAX - 2)
+#define VMBUS_RQST_RESET (U64_MAX - 3)
 
 struct vmbus_device {
        u16  dev_type;
@@ -1024,6 +1028,11 @@ struct vmbus_channel {
        u32 fuzz_testing_interrupt_delay;
        u32 fuzz_testing_message_delay;
 
+       /* callback to generate a request ID from a request address */
+       u64 (*next_request_id_callback)(struct vmbus_channel *channel, u64 rqst_addr);
+       /* callback to retrieve a request address from a request ID */
+       u64 (*request_addr_callback)(struct vmbus_channel *channel, u64 rqst_id);
+
        /* request/transaction ids for VMBus */
        struct vmbus_requestor requestor;
        u32 rqstor_size;
@@ -1032,8 +1041,8 @@ struct vmbus_channel {
        u32 max_pkt_size;
 };
 
-u64 vmbus_next_request_id(struct vmbus_requestor *rqstor, u64 rqst_addr);
-u64 vmbus_request_addr(struct vmbus_requestor *rqstor, u64 trans_id);
+u64 vmbus_next_request_id(struct vmbus_channel *channel, u64 rqst_addr);
+u64 vmbus_request_addr(struct vmbus_channel *channel, u64 trans_id);
 
 static inline bool is_hvsock_channel(const struct vmbus_channel *c)
 {