Commit bf5fd8ca authored by Andrea Parri (Microsoft)'s avatar Andrea Parri (Microsoft) Committed by Wei Liu
Browse files

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: default avatarMichael Kelley <mikelley@microsoft.com>
Signed-off-by: default avatarAndrea Parri (Microsoft) <parri.andrea@gmail.com>
Reviewed-by: default avatarMichael Kelley <mikelley@microsoft.com>
Acked-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
Link: https://lore.kernel.org/r/20210510210841.370472-1-parri.andrea@gmail.com


Signed-off-by: default avatarWei Liu <wei.liu@kernel.org>
parent adae1e93

drivers/hv/channel.c

+6 −8
Original line number Diff line number Diff line
@@ -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)

drivers/hv/ring_buffer.c

+8 −5
Original line number Diff line number Diff line
@@ -312,12 +312,14 @@ 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 (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;

	desc->trans_id = (rqst_id == VMBUS_NO_RQSTOR) ? requestid : rqst_id;
@@ -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;

	}

drivers/net/hyperv/netvsc.c

+5 −3
Original line number Diff line number Diff line
@@ -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,7 +817,7 @@ 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,

		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");
@@ -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;

drivers/net/hyperv/rndis_filter.c

+2 −0
Original line number Diff line number Diff line
@@ -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;

drivers/scsi/storvsc_drv.c

+63 −31
Original line number Diff line number Diff line
@@ -696,6 +696,23 @@ static void storvsc_change_target_cpu(struct vmbus_channel *channel, u32 old, 
	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,35 +1277,57 @@ static void storvsc_on_channel_callback(void *context) 
	if (!stor_device)

		return;



	shost = stor_device->host;



	foreach_vmbus_pkt(desc, channel) {

		void *packet = hv_pkt_data(desc);

		struct storvsc_cmd_request *request;

		u64 cmd_rqst;

		struct vstor_packet *packet = hv_pkt_data(desc);

		struct storvsc_cmd_request *request = NULL;

		u64 rqst_id = desc->trans_id;



		cmd_rqst = vmbus_request_addr(&channel->requestor,

					      desc->trans_id);

		if (cmd_rqst == VMBUS_RQST_ERROR) {

			dev_err(&device->device,

				"Incorrect transaction id\n");

		if (hv_pkt_datalen(desc) < sizeof(struct vstor_packet) -

				stor_device->vmscsi_size_delta) {

			dev_err(&device->device, "Invalid packet len\n");

			continue;

		}



		request = (struct storvsc_cmd_request *)(unsigned long)cmd_rqst;

		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;



		if (hv_pkt_datalen(desc) < sizeof(struct vstor_packet) -

				stor_device->vmscsi_size_delta) {

			dev_err(&device->device, "Invalid packet len\n");

				/* 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;

		}



		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);

		} else {

			storvsc_on_receive(stor_device, packet, request);

		}

	}

}
@@ -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)