Linux-HyperV Archive on lore.kernel.org
 help / color / Atom feed
* [PATCH v2 0/3] Drivers: hv: vmbus: vmbus_requestor data structure for VMBus hardening
@ 2020-06-29 20:02 Andres Beltran
  2020-06-29 20:02 ` [PATCH v2 1/3] Drivers: hv: vmbus: Add " Andres Beltran
                   ` (2 more replies)
  0 siblings, 3 replies; 16+ messages in thread
From: Andres Beltran @ 2020-06-29 20:02 UTC (permalink / raw)
  To: kys, haiyangz, sthemmin, wei.liu
  Cc: linux-hyperv, linux-kernel, mikelley, parri.andrea,
	Andres Beltran, linux-scsi, netdev, James E . J . Bottomley,
	Martin K . Petersen, David S . Miller, Jakub Kicinski

Currently, VMbus drivers use pointers into guest memory as request IDs
for interactions with Hyper-V. To be more robust in the face of errors
or malicious behavior from a compromised Hyper-V, avoid exposing
guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
bad request ID that is then treated as the address of a guest data
structure with no validation. Instead, encapsulate these memory
addresses and provide small integers as request IDs.

The first patch creates the definitions for the data structure, provides
helper methods to generate new IDs and retrieve data, and
allocates/frees the memory needed for vmbus_requestor.

The second and third patches make use of vmbus_requestor to send request
IDs to Hyper-V in storvsc and netvsc respectively.

Thanks.
Andres Beltran

Cc: linux-scsi@vger.kernel.org
Cc: netdev@vger.kernel.org
Cc: James E.J. Bottomley <jejb@linux.ibm.com>
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jakub Kicinski <kuba@kernel.org>

Andres Beltran (3):
  Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus
    hardening
  scsi: storvsc: Use vmbus_requestor to generate transaction IDs for
    VMBus hardening
  hv_netvsc: Use vmbus_requestor to generate transaction IDs for VMBus
    hardening

 drivers/hv/channel.c              | 146 ++++++++++++++++++++++++++++++
 drivers/net/hyperv/hyperv_net.h   |  13 +++
 drivers/net/hyperv/netvsc.c       |  79 +++++++++++++---
 drivers/net/hyperv/rndis_filter.c |   1 +
 drivers/scsi/storvsc_drv.c        |  85 ++++++++++++++---
 include/linux/hyperv.h            |  22 +++++
 6 files changed, 321 insertions(+), 25 deletions(-)

-- 
2.25.1


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 20:02 [PATCH v2 0/3] Drivers: hv: vmbus: vmbus_requestor data structure for VMBus hardening Andres Beltran
@ 2020-06-29 20:02 ` Andres Beltran
  2020-06-29 20:46   ` Wei Liu
  2020-06-29 20:02 ` [PATCH v2 2/3] scsi: storvsc: Use vmbus_requestor to generate transaction IDs " Andres Beltran
  2020-06-29 20:02 ` [PATCH v2 3/3] hv_netvsc: " Andres Beltran
  2 siblings, 1 reply; 16+ messages in thread
From: Andres Beltran @ 2020-06-29 20:02 UTC (permalink / raw)
  To: kys, haiyangz, sthemmin, wei.liu
  Cc: linux-hyperv, linux-kernel, mikelley, parri.andrea, Andres Beltran

Currently, VMbus drivers use pointers into guest memory as request IDs
for interactions with Hyper-V. To be more robust in the face of errors
or malicious behavior from a compromised Hyper-V, avoid exposing
guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
bad request ID that is then treated as the address of a guest data
structure with no validation. Instead, encapsulate these memory
addresses and provide small integers as request IDs.

Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
---
Changes in v2:
	- Get rid of "rqstor" variable in __vmbus_open().

 drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
 include/linux/hyperv.h |  21 ++++++
 2 files changed, 167 insertions(+)

diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
index 3ebda7707e46..c89d57d0c2d2 100644
--- a/drivers/hv/channel.c
+++ b/drivers/hv/channel.c
@@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
 }
 EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
 
+/**
+ * request_arr_init - Allocates memory for the requestor array. Each slot
+ * keeps track of the next available slot in the array. Initially, each
+ * slot points to the next one (as in a Linked List). The last slot
+ * does not point to anything, so its value is U64_MAX by default.
+ * @size The size of the array
+ */
+static u64 *request_arr_init(u32 size)
+{
+	int i;
+	u64 *req_arr;
+
+	req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
+	if (!req_arr)
+		return NULL;
+
+	for (i = 0; i < size - 1; i++)
+		req_arr[i] = i + 1;
+
+	/* Last slot (no more available slots) */
+	req_arr[i] = U64_MAX;
+
+	return req_arr;
+}
+
+/*
+ * vmbus_alloc_requestor - Initializes @rqstor's fields.
+ * Slot at index 0 is the first free slot.
+ * @size: Size of the requestor array
+ */
+static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
+{
+	u64 *rqst_arr;
+	unsigned long *bitmap;
+
+	rqst_arr = request_arr_init(size);
+	if (!rqst_arr)
+		return -ENOMEM;
+
+	bitmap = bitmap_zalloc(size, GFP_KERNEL);
+	if (!bitmap) {
+		kfree(rqst_arr);
+		return -ENOMEM;
+	}
+
+	rqstor->req_arr = rqst_arr;
+	rqstor->req_bitmap = bitmap;
+	rqstor->size = size;
+	rqstor->next_request_id = 0;
+	spin_lock_init(&rqstor->req_lock);
+
+	return 0;
+}
+
+/*
+ * vmbus_free_requestor - Frees memory allocated for @rqstor
+ * @rqstor: Pointer to the requestor struct
+ */
+static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
+{
+	kfree(rqstor->req_arr);
+	bitmap_free(rqstor->req_bitmap);
+}
+
 static int __vmbus_open(struct vmbus_channel *newchannel,
 		       void *userdata, u32 userdatalen,
 		       void (*onchannelcallback)(void *context), void *context)
@@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
 	if (newchannel->state != CHANNEL_OPEN_STATE)
 		return -EINVAL;
 
+	/* Create and init requestor */
+	if (newchannel->rqstor_size) {
+		if (vmbus_alloc_requestor(&newchannel->requestor, newchannel->rqstor_size))
+			return -ENOMEM;
+	}
+
 	newchannel->state = CHANNEL_OPENING_STATE;
 	newchannel->onchannel_callback = onchannelcallback;
 	newchannel->channel_callback_context = context;
@@ -228,6 +298,7 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
 error_clean_ring:
 	hv_ringbuffer_cleanup(&newchannel->outbound);
 	hv_ringbuffer_cleanup(&newchannel->inbound);
+	vmbus_free_requestor(&newchannel->requestor);
 	newchannel->state = CHANNEL_OPEN_STATE;
 	return err;
 }
@@ -703,6 +774,9 @@ static int vmbus_close_internal(struct vmbus_channel *channel)
 		channel->ringbuffer_gpadlhandle = 0;
 	}
 
+	if (!ret)
+		vmbus_free_requestor(&channel->requestor);
+
 	return ret;
 }
 
@@ -937,3 +1011,75 @@ int vmbus_recvpacket_raw(struct vmbus_channel *channel, void *buffer,
 				  buffer_actual_len, requestid, true);
 }
 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
+ * @rqst_add: Guest memory address to be stored in the array
+ */
+u64 vmbus_next_request_id(struct vmbus_requestor *rqstor, u64 rqst_addr)
+{
+	unsigned long flags;
+	u64 current_id;
+
+	spin_lock_irqsave(&rqstor->req_lock, flags);
+	current_id = rqstor->next_request_id;
+
+	/* Requestor array is full */
+	if (current_id >= rqstor->size) {
+		current_id = VMBUS_RQST_ERROR;
+		goto exit;
+	}
+
+	rqstor->next_request_id = rqstor->req_arr[current_id];
+	rqstor->req_arr[current_id] = rqst_addr;
+
+	/* The already held spin lock provides atomicity */
+	bitmap_set(rqstor->req_bitmap, current_id, 1);
+
+exit:
+	spin_unlock_irqrestore(&rqstor->req_lock, flags);
+	return current_id;
+}
+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
+ * @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)
+{
+	unsigned long flags;
+	u64 req_addr;
+
+	spin_lock_irqsave(&rqstor->req_lock, flags);
+
+	/* Invalid trans_id */
+	if (trans_id >= rqstor->size) {
+		req_addr = VMBUS_RQST_ERROR;
+		goto exit;
+	}
+
+	/* Invalid trans_id: empty slot */
+	if (!test_bit(trans_id, rqstor->req_bitmap)) {
+		req_addr = VMBUS_RQST_ERROR;
+		goto exit;
+	}
+
+	req_addr = rqstor->req_arr[trans_id];
+	rqstor->req_arr[trans_id] = rqstor->next_request_id;
+	rqstor->next_request_id = trans_id;
+
+	/* The already held spin lock provides atomicity */
+	bitmap_clear(rqstor->req_bitmap, trans_id, 1);
+
+exit:
+	spin_unlock_irqrestore(&rqstor->req_lock, flags);
+	return req_addr;
+}
+EXPORT_SYMBOL_GPL(vmbus_request_addr);
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 38100e80360a..c509d20ab7db 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -716,6 +716,21 @@ enum vmbus_device_type {
 	HV_UNKNOWN,
 };
 
+/*
+ * Provides request ids for VMBus. Encapsulates guest memory
+ * addresses and stores the next available slot in req_arr
+ * to generate new ids in constant time.
+ */
+struct vmbus_requestor {
+	u64 *req_arr;
+	unsigned long *req_bitmap; /* is a given slot available? */
+	u32 size;
+	u64 next_request_id;
+	spinlock_t req_lock; /* provides atomicity */
+};
+
+#define VMBUS_RQST_ERROR U64_MAX
+
 struct vmbus_device {
 	u16  dev_type;
 	guid_t guid;
@@ -940,8 +955,14 @@ struct vmbus_channel {
 	u32 fuzz_testing_interrupt_delay;
 	u32 fuzz_testing_message_delay;
 
+	/* request/transaction ids for VMBus */
+	struct vmbus_requestor requestor;
+	u32 rqstor_size;
 };
 
+u64 vmbus_next_request_id(struct vmbus_requestor *rqstor, u64 rqst_addr);
+u64 vmbus_request_addr(struct vmbus_requestor *rqstor, u64 trans_id);
+
 static inline bool is_hvsock_channel(const struct vmbus_channel *c)
 {
 	return !!(c->offermsg.offer.chn_flags &
-- 
2.25.1


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [PATCH v2 2/3] scsi: storvsc: Use vmbus_requestor to generate transaction IDs for VMBus hardening
  2020-06-29 20:02 [PATCH v2 0/3] Drivers: hv: vmbus: vmbus_requestor data structure for VMBus hardening Andres Beltran
  2020-06-29 20:02 ` [PATCH v2 1/3] Drivers: hv: vmbus: Add " Andres Beltran
@ 2020-06-29 20:02 ` Andres Beltran
  2020-06-29 20:02 ` [PATCH v2 3/3] hv_netvsc: " Andres Beltran
  2 siblings, 0 replies; 16+ messages in thread
From: Andres Beltran @ 2020-06-29 20:02 UTC (permalink / raw)
  To: kys, haiyangz, sthemmin, wei.liu
  Cc: linux-hyperv, linux-kernel, mikelley, parri.andrea,
	Andres Beltran, James E.J. Bottomley, Martin K. Petersen,
	linux-scsi

Currently, pointers to guest memory are passed to Hyper-V as
transaction IDs in storvsc. In the face of errors or malicious
behavior in Hyper-V, storvsc should not expose or trust the transaction
IDs returned by Hyper-V to be valid guest memory addresses. Instead,
use small integers generated by vmbus_requestor as requests
(transaction) IDs.

Cc: "James E.J. Bottomley" <jejb@linux.ibm.com>
Cc: "Martin K. Petersen" <martin.petersen@oracle.com>
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
---
Changes in v2:
	- Add casts to unsigned long to fix warnings on 32bit.

 drivers/scsi/storvsc_drv.c | 85 +++++++++++++++++++++++++++++++++-----
 1 file changed, 74 insertions(+), 11 deletions(-)

diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
index 624467e2590a..6d2df1f0fe6d 100644
--- a/drivers/scsi/storvsc_drv.c
+++ b/drivers/scsi/storvsc_drv.c
@@ -399,6 +399,7 @@ static int storvsc_timeout = 180;
 static struct scsi_transport_template *fc_transport_template;
 #endif
 
+static struct scsi_host_template scsi_driver;
 static void storvsc_on_channel_callback(void *context);
 
 #define STORVSC_MAX_LUNS_PER_TARGET			255
@@ -698,6 +699,12 @@ static void handle_sc_creation(struct vmbus_channel *new_sc)
 
 	memset(&props, 0, sizeof(struct vmstorage_channel_properties));
 
+	/*
+	 * 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;
+
 	ret = vmbus_open(new_sc,
 			 storvsc_ringbuffer_size,
 			 storvsc_ringbuffer_size,
@@ -726,6 +733,7 @@ static void  handle_multichannel_storage(struct hv_device *device, int max_chns)
 	struct storvsc_cmd_request *request;
 	struct vstor_packet *vstor_packet;
 	int ret, t;
+	u64 rqst_id;
 
 	/*
 	 * If the number of CPUs is artificially restricted, such as
@@ -760,14 +768,23 @@ static void  handle_multichannel_storage(struct hv_device *device, int max_chns)
 	vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 	vstor_packet->sub_channel_count = num_sc;
 
+	rqst_id = vmbus_next_request_id(&device->channel->requestor,
+					(unsigned long)request);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		dev_err(dev, "No request id available\n");
+		return;
+	}
+
 	ret = vmbus_sendpacket(device->channel, vstor_packet,
 			       (sizeof(struct vstor_packet) -
 			       vmscsi_size_delta),
-			       (unsigned long)request,
+			       rqst_id,
 			       VM_PKT_DATA_INBAND,
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 
 	if (ret != 0) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&device->channel->requestor, rqst_id);
 		dev_err(dev, "Failed to create sub-channel: err=%d\n", ret);
 		return;
 	}
@@ -818,20 +835,31 @@ static int storvsc_execute_vstor_op(struct hv_device *device,
 {
 	struct vstor_packet *vstor_packet;
 	int ret, t;
+	u64 rqst_id;
 
 	vstor_packet = &request->vstor_packet;
 
 	init_completion(&request->wait_event);
 	vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 
+	rqst_id = vmbus_next_request_id(&device->channel->requestor,
+					(unsigned long)request);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		dev_err(&device->device, "No request id available\n");
+		return -EAGAIN;
+	}
+
 	ret = vmbus_sendpacket(device->channel, vstor_packet,
 			       (sizeof(struct vstor_packet) -
 			       vmscsi_size_delta),
-			       (unsigned long)request,
+			       rqst_id,
 			       VM_PKT_DATA_INBAND,
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
-	if (ret != 0)
+	if (ret != 0) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&device->channel->requestor, rqst_id);
 		return ret;
+	}
 
 	t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 	if (t == 0)
@@ -1233,9 +1261,17 @@ static void storvsc_on_channel_callback(void *context)
 	foreach_vmbus_pkt(desc, channel) {
 		void *packet = hv_pkt_data(desc);
 		struct storvsc_cmd_request *request;
+		u64 cmd_rqst;
 
-		request = (struct storvsc_cmd_request *)
-			((unsigned long)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");
+			continue;
+		}
+
+		request = (struct storvsc_cmd_request *)(unsigned long)cmd_rqst;
 
 		if (request == &stor_device->init_request ||
 		    request == &stor_device->reset_request) {
@@ -1256,6 +1292,12 @@ static int storvsc_connect_to_vsp(struct hv_device *device, u32 ring_size,
 
 	memset(&props, 0, sizeof(struct vmstorage_channel_properties));
 
+	/*
+	 * 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;
+
 	ret = vmbus_open(device->channel,
 			 ring_size,
 			 ring_size,
@@ -1369,6 +1411,7 @@ static int storvsc_do_io(struct hv_device *device,
 	int ret = 0;
 	const struct cpumask *node_mask;
 	int tgt_cpu;
+	u64 rqst_id;
 
 	vstor_packet = &request->vstor_packet;
 	stor_device = get_out_stor_device(device);
@@ -1463,6 +1506,13 @@ static int storvsc_do_io(struct hv_device *device,
 
 	vstor_packet->operation = VSTOR_OPERATION_EXECUTE_SRB;
 
+	rqst_id = vmbus_next_request_id(&outgoing_channel->requestor,
+					(unsigned long)request);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		dev_err(&device->device, "No request id available\n");
+		return -EAGAIN;
+	}
+
 	if (request->payload->range.len) {
 
 		ret = vmbus_sendpacket_mpb_desc(outgoing_channel,
@@ -1470,18 +1520,21 @@ static int storvsc_do_io(struct hv_device *device,
 				vstor_packet,
 				(sizeof(struct vstor_packet) -
 				vmscsi_size_delta),
-				(unsigned long)request);
+				rqst_id);
 	} else {
 		ret = vmbus_sendpacket(outgoing_channel, vstor_packet,
 			       (sizeof(struct vstor_packet) -
 				vmscsi_size_delta),
-			       (unsigned long)request,
+			       rqst_id,
 			       VM_PKT_DATA_INBAND,
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 	}
 
-	if (ret != 0)
+	if (ret != 0) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&outgoing_channel->requestor, rqst_id);
 		return ret;
+	}
 
 	atomic_inc(&stor_device->num_outstanding_req);
 
@@ -1562,7 +1615,7 @@ static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
 	struct storvsc_cmd_request *request;
 	struct vstor_packet *vstor_packet;
 	int ret, t;
-
+	u64 rqst_id;
 
 	stor_device = get_out_stor_device(device);
 	if (!stor_device)
@@ -1577,14 +1630,24 @@ static int storvsc_host_reset_handler(struct scsi_cmnd *scmnd)
 	vstor_packet->flags = REQUEST_COMPLETION_FLAG;
 	vstor_packet->vm_srb.path_id = stor_device->path_id;
 
+	rqst_id = vmbus_next_request_id(&device->channel->requestor,
+					(unsigned long)&stor_device->reset_request);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		dev_err(&device->device, "No request id available\n");
+		return FAILED;
+	}
+
 	ret = vmbus_sendpacket(device->channel, vstor_packet,
 			       (sizeof(struct vstor_packet) -
 				vmscsi_size_delta),
-			       (unsigned long)&stor_device->reset_request,
+			       rqst_id,
 			       VM_PKT_DATA_INBAND,
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
-	if (ret != 0)
+	if (ret != 0) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&device->channel->requestor, rqst_id);
 		return FAILED;
+	}
 
 	t = wait_for_completion_timeout(&request->wait_event, 5*HZ);
 	if (t == 0)
-- 
2.25.1


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [PATCH v2 3/3] hv_netvsc: Use vmbus_requestor to generate transaction IDs for VMBus hardening
  2020-06-29 20:02 [PATCH v2 0/3] Drivers: hv: vmbus: vmbus_requestor data structure for VMBus hardening Andres Beltran
  2020-06-29 20:02 ` [PATCH v2 1/3] Drivers: hv: vmbus: Add " Andres Beltran
  2020-06-29 20:02 ` [PATCH v2 2/3] scsi: storvsc: Use vmbus_requestor to generate transaction IDs " Andres Beltran
@ 2020-06-29 20:02 ` Andres Beltran
  2020-06-29 21:33   ` Haiyang Zhang
  2 siblings, 1 reply; 16+ messages in thread
From: Andres Beltran @ 2020-06-29 20:02 UTC (permalink / raw)
  To: kys, haiyangz, sthemmin, wei.liu
  Cc: linux-hyperv, linux-kernel, mikelley, parri.andrea,
	Andres Beltran, David S . Miller, Jakub Kicinski, netdev

Currently, pointers to guest memory are passed to Hyper-V as
transaction IDs in netvsc. In the face of errors or malicious
behavior in Hyper-V, netvsc should not expose or trust the transaction
IDs returned by Hyper-V to be valid guest memory addresses. Instead,
use small integers generated by vmbus_requestor as requests
(transaction) IDs.

Cc: David S. Miller <davem@davemloft.net>
Cc: Jakub Kicinski <kuba@kernel.org>
Cc: netdev@vger.kernel.org
Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
---
Changes in v2:
	- Add casts to unsigned long to fix warnings on 32bit.
	- Use an inline function to get the requestor size.

 drivers/net/hyperv/hyperv_net.h   | 13 +++++
 drivers/net/hyperv/netvsc.c       | 79 +++++++++++++++++++++++++------
 drivers/net/hyperv/rndis_filter.c |  1 +
 include/linux/hyperv.h            |  1 +
 4 files changed, 80 insertions(+), 14 deletions(-)

diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_net.h
index abda736e7c7d..f43b614f2345 100644
--- a/drivers/net/hyperv/hyperv_net.h
+++ b/drivers/net/hyperv/hyperv_net.h
@@ -847,6 +847,19 @@ struct nvsp_message {
 
 #define NETVSC_XDP_HDRM 256
 
+#define NETVSC_MIN_OUT_MSG_SIZE (sizeof(struct vmpacket_descriptor) + \
+				 sizeof(struct nvsp_message))
+#define NETVSC_MIN_IN_MSG_SIZE sizeof(struct vmpacket_descriptor)
+
+/* Estimated requestor size:
+ * out_ring_size/min_out_msg_size + in_ring_size/min_in_msg_size
+ */
+static inline u32 netvsc_rqstor_size(unsigned long ringbytes)
+{
+	return ringbytes / NETVSC_MIN_OUT_MSG_SIZE +
+	       ringbytes / NETVSC_MIN_IN_MSG_SIZE;
+}
+
 struct multi_send_data {
 	struct sk_buff *skb; /* skb containing the pkt */
 	struct hv_netvsc_packet *pkt; /* netvsc pkt pending */
diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c
index 41f5cf0bb997..79b907a29433 100644
--- a/drivers/net/hyperv/netvsc.c
+++ b/drivers/net/hyperv/netvsc.c
@@ -50,7 +50,7 @@ void netvsc_switch_datapath(struct net_device *ndev, bool vf)
 
 	vmbus_sendpacket(dev->channel, init_pkt,
 			       sizeof(struct nvsp_message),
-			       (unsigned long)init_pkt,
+			       VMBUS_RQST_ID_NO_RESPONSE,
 			       VM_PKT_DATA_INBAND, 0);
 }
 
@@ -163,7 +163,7 @@ static void netvsc_revoke_recv_buf(struct hv_device *device,
 		ret = vmbus_sendpacket(device->channel,
 				       revoke_packet,
 				       sizeof(struct nvsp_message),
-				       (unsigned long)revoke_packet,
+				       VMBUS_RQST_ID_NO_RESPONSE,
 				       VM_PKT_DATA_INBAND, 0);
 		/* If the failure is because the channel is rescinded;
 		 * ignore the failure since we cannot send on a rescinded
@@ -213,7 +213,7 @@ static void netvsc_revoke_send_buf(struct hv_device *device,
 		ret = vmbus_sendpacket(device->channel,
 				       revoke_packet,
 				       sizeof(struct nvsp_message),
-				       (unsigned long)revoke_packet,
+				       VMBUS_RQST_ID_NO_RESPONSE,
 				       VM_PKT_DATA_INBAND, 0);
 
 		/* If the failure is because the channel is rescinded;
@@ -304,6 +304,7 @@ static int netvsc_init_buf(struct hv_device *device,
 	unsigned int buf_size;
 	size_t map_words;
 	int ret = 0;
+	u64 rqst_id;
 
 	/* Get receive buffer area. */
 	buf_size = device_info->recv_sections * device_info->recv_section_size;
@@ -350,13 +351,22 @@ static int netvsc_init_buf(struct hv_device *device,
 
 	trace_nvsp_send(ndev, init_packet);
 
+	rqst_id = vmbus_next_request_id(&device->channel->requestor,
+					(unsigned long)init_packet);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		netdev_err(ndev, "No request id available\n");
+		goto cleanup;
+	}
+
 	/* Send the gpadl notification request */
 	ret = vmbus_sendpacket(device->channel, init_packet,
 			       sizeof(struct nvsp_message),
-			       (unsigned long)init_packet,
+			       rqst_id,
 			       VM_PKT_DATA_INBAND,
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 	if (ret != 0) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&device->channel->requestor, rqst_id);
 		netdev_err(ndev,
 			"unable to send receive buffer's gpadl to netvsp\n");
 		goto cleanup;
@@ -432,13 +442,22 @@ static int netvsc_init_buf(struct hv_device *device,
 
 	trace_nvsp_send(ndev, init_packet);
 
+	rqst_id = vmbus_next_request_id(&device->channel->requestor,
+					(unsigned long)init_packet);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		netdev_err(ndev, "No request id available\n");
+		goto cleanup;
+	}
+
 	/* Send the gpadl notification request */
 	ret = vmbus_sendpacket(device->channel, init_packet,
 			       sizeof(struct nvsp_message),
-			       (unsigned long)init_packet,
+			       rqst_id,
 			       VM_PKT_DATA_INBAND,
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 	if (ret != 0) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&device->channel->requestor, rqst_id);
 		netdev_err(ndev,
 			   "unable to send send buffer's gpadl to netvsp\n");
 		goto cleanup;
@@ -496,6 +515,7 @@ static int negotiate_nvsp_ver(struct hv_device *device,
 {
 	struct net_device *ndev = hv_get_drvdata(device);
 	int ret;
+	u64 rqst_id;
 
 	memset(init_packet, 0, sizeof(struct nvsp_message));
 	init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
@@ -503,15 +523,25 @@ static int negotiate_nvsp_ver(struct hv_device *device,
 	init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
 	trace_nvsp_send(ndev, init_packet);
 
+	rqst_id = vmbus_next_request_id(&device->channel->requestor,
+					(unsigned long)init_packet);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		netdev_err(ndev, "No request id available\n");
+		return -EAGAIN;
+	}
+
 	/* Send the init request */
 	ret = vmbus_sendpacket(device->channel, init_packet,
 			       sizeof(struct nvsp_message),
-			       (unsigned long)init_packet,
+			       rqst_id,
 			       VM_PKT_DATA_INBAND,
 			       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 
-	if (ret != 0)
+	if (ret != 0) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&device->channel->requestor, rqst_id);
 		return ret;
+	}
 
 	wait_for_completion(&net_device->channel_init_wait);
 
@@ -542,7 +572,7 @@ static int negotiate_nvsp_ver(struct hv_device *device,
 
 	ret = vmbus_sendpacket(device->channel, init_packet,
 				sizeof(struct nvsp_message),
-				(unsigned long)init_packet,
+				VMBUS_RQST_ID_NO_RESPONSE,
 				VM_PKT_DATA_INBAND, 0);
 
 	return ret;
@@ -599,7 +629,7 @@ static int netvsc_connect_vsp(struct hv_device *device,
 	/* Send the init request */
 	ret = vmbus_sendpacket(device->channel, init_packet,
 				sizeof(struct nvsp_message),
-				(unsigned long)init_packet,
+				VMBUS_RQST_ID_NO_RESPONSE,
 				VM_PKT_DATA_INBAND, 0);
 	if (ret != 0)
 		goto cleanup;
@@ -680,10 +710,19 @@ static void netvsc_send_tx_complete(struct net_device *ndev,
 				    const struct vmpacket_descriptor *desc,
 				    int budget)
 {
-	struct sk_buff *skb = (struct sk_buff *)(unsigned long)desc->trans_id;
+	struct sk_buff *skb;
 	struct net_device_context *ndev_ctx = netdev_priv(ndev);
 	u16 q_idx = 0;
 	int queue_sends;
+	u64 cmd_rqst;
+
+	cmd_rqst = vmbus_request_addr(&channel->requestor, (u64)desc->trans_id);
+	if (cmd_rqst == VMBUS_RQST_ERROR) {
+		netdev_err(ndev, "Incorrect transaction id\n");
+		return;
+	}
+
+	skb = (struct sk_buff *)(unsigned long)cmd_rqst;
 
 	/* Notify the layer above us */
 	if (likely(skb)) {
@@ -822,7 +861,7 @@ static inline int netvsc_send_pkt(
 	struct net_device *ndev = hv_get_drvdata(device);
 	struct net_device_context *ndev_ctx = netdev_priv(ndev);
 	struct netdev_queue *txq = netdev_get_tx_queue(ndev, packet->q_idx);
-	u64 req_id;
+	u64 rqst_id;
 	int ret;
 	u32 ring_avail = hv_get_avail_to_write_percent(&out_channel->outbound);
 
@@ -838,13 +877,19 @@ static inline int netvsc_send_pkt(
 	else
 		rpkt->send_buf_section_size = packet->total_data_buflen;
 
-	req_id = (ulong)skb;
 
 	if (out_channel->rescind)
 		return -ENODEV;
 
 	trace_nvsp_send_pkt(ndev, out_channel, rpkt);
 
+	rqst_id = vmbus_next_request_id(&out_channel->requestor,
+					(unsigned long)skb);
+	if (rqst_id == VMBUS_RQST_ERROR) {
+		ret = -EAGAIN;
+		goto ret_check;
+	}
+
 	if (packet->page_buf_cnt) {
 		if (packet->cp_partial)
 			pb += packet->rmsg_pgcnt;
@@ -852,14 +897,15 @@ static inline int netvsc_send_pkt(
 		ret = vmbus_sendpacket_pagebuffer(out_channel,
 						  pb, packet->page_buf_cnt,
 						  &nvmsg, sizeof(nvmsg),
-						  req_id);
+						  rqst_id);
 	} else {
 		ret = vmbus_sendpacket(out_channel,
 				       &nvmsg, sizeof(nvmsg),
-				       req_id, VM_PKT_DATA_INBAND,
+				       rqst_id, VM_PKT_DATA_INBAND,
 				       VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 	}
 
+ret_check:
 	if (ret == 0) {
 		atomic_inc_return(&nvchan->queue_sends);
 
@@ -868,9 +914,13 @@ static inline int netvsc_send_pkt(
 			ndev_ctx->eth_stats.stop_queue++;
 		}
 	} else if (ret == -EAGAIN) {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&out_channel->requestor, rqst_id);
 		netif_tx_stop_queue(txq);
 		ndev_ctx->eth_stats.stop_queue++;
 	} else {
+		/* Reclaim request ID to avoid leak of IDs */
+		vmbus_request_addr(&out_channel->requestor, rqst_id);
 		netdev_err(ndev,
 			   "Unable to send packet pages %u len %u, ret %d\n",
 			   packet->page_buf_cnt, packet->total_data_buflen,
@@ -1422,6 +1472,7 @@ struct netvsc_device *netvsc_device_add(struct hv_device *device,
 		       netvsc_poll, NAPI_POLL_WEIGHT);
 
 	/* Open the channel */
+	device->channel->rqstor_size = netvsc_rqstor_size(netvsc_ring_bytes);
 	ret = vmbus_open(device->channel, netvsc_ring_bytes,
 			 netvsc_ring_bytes,  NULL, 0,
 			 netvsc_channel_cb, net_device->chan_table);
diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index b81ceba38218..10489ba44a09 100644
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -1114,6 +1114,7 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
 	/* Set the channel before opening.*/
 	nvchan->channel = new_sc;
 
+	new_sc->rqstor_size = netvsc_rqstor_size(netvsc_ring_bytes);
 	ret = vmbus_open(new_sc, netvsc_ring_bytes,
 			 netvsc_ring_bytes, NULL, 0,
 			 netvsc_channel_cb, nvchan);
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index c509d20ab7db..d8194924983d 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -730,6 +730,7 @@ struct vmbus_requestor {
 };
 
 #define VMBUS_RQST_ERROR U64_MAX
+#define VMBUS_RQST_ID_NO_RESPONSE (U64_MAX - 1)
 
 struct vmbus_device {
 	u16  dev_type;
-- 
2.25.1


^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 20:02 ` [PATCH v2 1/3] Drivers: hv: vmbus: Add " Andres Beltran
@ 2020-06-29 20:46   ` Wei Liu
  2020-06-29 21:51     ` Andres Beltran
  0 siblings, 1 reply; 16+ messages in thread
From: Wei Liu @ 2020-06-29 20:46 UTC (permalink / raw)
  To: t-mabelt
  Cc: kys, haiyangz, sthemmin, wei.liu, linux-hyperv, linux-kernel,
	mikelley, parri.andrea, Andres Beltran

On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> Currently, VMbus drivers use pointers into guest memory as request IDs
> for interactions with Hyper-V. To be more robust in the face of errors
> or malicious behavior from a compromised Hyper-V, avoid exposing
> guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> bad request ID that is then treated as the address of a guest data
> structure with no validation. Instead, encapsulate these memory
> addresses and provide small integers as request IDs.
> 
> Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> ---
> Changes in v2:
> 	- Get rid of "rqstor" variable in __vmbus_open().
> 
>  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
>  include/linux/hyperv.h |  21 ++++++
>  2 files changed, 167 insertions(+)
> 
> diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> index 3ebda7707e46..c89d57d0c2d2 100644
> --- a/drivers/hv/channel.c
> +++ b/drivers/hv/channel.c
> @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
>  }
>  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
>  
> +/**
> + * request_arr_init - Allocates memory for the requestor array. Each slot
> + * keeps track of the next available slot in the array. Initially, each
> + * slot points to the next one (as in a Linked List). The last slot
> + * does not point to anything, so its value is U64_MAX by default.
> + * @size The size of the array
> + */
> +static u64 *request_arr_init(u32 size)
> +{
> +	int i;
> +	u64 *req_arr;
> +
> +	req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> +	if (!req_arr)
> +		return NULL;
> +
> +	for (i = 0; i < size - 1; i++)
> +		req_arr[i] = i + 1;
> +
> +	/* Last slot (no more available slots) */
> +	req_arr[i] = U64_MAX;
> +
> +	return req_arr;
> +}
> +
> +/*
> + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> + * Slot at index 0 is the first free slot.
> + * @size: Size of the requestor array
> + */
> +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> +{
> +	u64 *rqst_arr;
> +	unsigned long *bitmap;
> +
> +	rqst_arr = request_arr_init(size);
> +	if (!rqst_arr)
> +		return -ENOMEM;
> +
> +	bitmap = bitmap_zalloc(size, GFP_KERNEL);
> +	if (!bitmap) {
> +		kfree(rqst_arr);
> +		return -ENOMEM;
> +	}
> +
> +	rqstor->req_arr = rqst_arr;
> +	rqstor->req_bitmap = bitmap;
> +	rqstor->size = size;
> +	rqstor->next_request_id = 0;
> +	spin_lock_init(&rqstor->req_lock);
> +
> +	return 0;
> +}
> +
> +/*
> + * vmbus_free_requestor - Frees memory allocated for @rqstor
> + * @rqstor: Pointer to the requestor struct
> + */
> +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> +{
> +	kfree(rqstor->req_arr);
> +	bitmap_free(rqstor->req_bitmap);
> +}
> +
>  static int __vmbus_open(struct vmbus_channel *newchannel,
>  		       void *userdata, u32 userdatalen,
>  		       void (*onchannelcallback)(void *context), void *context)
> @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
>  	if (newchannel->state != CHANNEL_OPEN_STATE)
>  		return -EINVAL;
>  
> +	/* Create and init requestor */
> +	if (newchannel->rqstor_size) {
> +		if (vmbus_alloc_requestor(&newchannel->requestor, newchannel->rqstor_size))
> +			return -ENOMEM;
> +	}
> +

Sorry for not noticing this in the last round: this infrastructure is
initialized conditionally but used unconditionally.

I can think of two options here:

  1. Mandate rqstor_size to be non-zero. Always initialize this
     infra.
  2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
     uninitialized state.

For #2, you can simply check rqstor->size _before_ taking the lock
(because it may be uninitialized, and the assumption is ->size will not
change during the channel's lifetime, hence no lock is needed) and
simply return the same value to the caller.

Wei.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* RE: [PATCH v2 3/3] hv_netvsc: Use vmbus_requestor to generate transaction IDs for VMBus hardening
  2020-06-29 20:02 ` [PATCH v2 3/3] hv_netvsc: " Andres Beltran
@ 2020-06-29 21:33   ` Haiyang Zhang
  2020-06-29 22:26     ` Wei Liu
  0 siblings, 1 reply; 16+ messages in thread
From: Haiyang Zhang @ 2020-06-29 21:33 UTC (permalink / raw)
  To: Andres Beltran, KY Srinivasan, Stephen Hemminger, wei.liu
  Cc: linux-hyperv, linux-kernel, Michael Kelley, parri.andrea,
	David S . Miller, Jakub Kicinski, netdev



> -----Original Message-----
> From: Andres Beltran <lkmlabelt@gmail.com>
> Sent: Monday, June 29, 2020 4:02 PM
> To: KY Srinivasan <kys@microsoft.com>; Haiyang Zhang
> <haiyangz@microsoft.com>; Stephen Hemminger <sthemmin@microsoft.com>;
> wei.liu@kernel.org
> Cc: linux-hyperv@vger.kernel.org; linux-kernel@vger.kernel.org; Michael
> Kelley <mikelley@microsoft.com>; parri.andrea@gmail.com; Andres Beltran
> <lkmlabelt@gmail.com>; David S . Miller <davem@davemloft.net>; Jakub
> Kicinski <kuba@kernel.org>; netdev@vger.kernel.org
> Subject: [PATCH v2 3/3] hv_netvsc: Use vmbus_requestor to generate
> transaction IDs for VMBus hardening
> 
> Currently, pointers to guest memory are passed to Hyper-V as
> transaction IDs in netvsc. In the face of errors or malicious
> behavior in Hyper-V, netvsc should not expose or trust the transaction
> IDs returned by Hyper-V to be valid guest memory addresses. Instead,
> use small integers generated by vmbus_requestor as requests
> (transaction) IDs.
> 
> Cc: David S. Miller <davem@davemloft.net>
> Cc: Jakub Kicinski <kuba@kernel.org>
> Cc: netdev@vger.kernel.org
> Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>

Reviewed-by: Haiyang Zhang <haiyangz@microsoft.com>



^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 20:46   ` Wei Liu
@ 2020-06-29 21:51     ` Andres Beltran
  2020-06-29 21:56       ` Michael Kelley
  2020-06-29 22:20       ` Wei Liu
  0 siblings, 2 replies; 16+ messages in thread
From: Andres Beltran @ 2020-06-29 21:51 UTC (permalink / raw)
  To: Wei Liu
  Cc: Andres Beltran, kys, haiyangz, sthemmin, linux-hyperv,
	linux-kernel, Michael Kelley, Andrea Parri

On Mon, Jun 29, 2020 at 4:46 PM Wei Liu <wei.liu@kernel.org> wrote:
>
> On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> > Currently, VMbus drivers use pointers into guest memory as request IDs
> > for interactions with Hyper-V. To be more robust in the face of errors
> > or malicious behavior from a compromised Hyper-V, avoid exposing
> > guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> > bad request ID that is then treated as the address of a guest data
> > structure with no validation. Instead, encapsulate these memory
> > addresses and provide small integers as request IDs.
> >
> > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> > ---
> > Changes in v2:
> >       - Get rid of "rqstor" variable in __vmbus_open().
> >
> >  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
> >  include/linux/hyperv.h |  21 ++++++
> >  2 files changed, 167 insertions(+)
> >
> > diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> > index 3ebda7707e46..c89d57d0c2d2 100644
> > --- a/drivers/hv/channel.c
> > +++ b/drivers/hv/channel.c
> > @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
> >  }
> >  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
> >
> > +/**
> > + * request_arr_init - Allocates memory for the requestor array. Each slot
> > + * keeps track of the next available slot in the array. Initially, each
> > + * slot points to the next one (as in a Linked List). The last slot
> > + * does not point to anything, so its value is U64_MAX by default.
> > + * @size The size of the array
> > + */
> > +static u64 *request_arr_init(u32 size)
> > +{
> > +     int i;
> > +     u64 *req_arr;
> > +
> > +     req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> > +     if (!req_arr)
> > +             return NULL;
> > +
> > +     for (i = 0; i < size - 1; i++)
> > +             req_arr[i] = i + 1;
> > +
> > +     /* Last slot (no more available slots) */
> > +     req_arr[i] = U64_MAX;
> > +
> > +     return req_arr;
> > +}
> > +
> > +/*
> > + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> > + * Slot at index 0 is the first free slot.
> > + * @size: Size of the requestor array
> > + */
> > +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> > +{
> > +     u64 *rqst_arr;
> > +     unsigned long *bitmap;
> > +
> > +     rqst_arr = request_arr_init(size);
> > +     if (!rqst_arr)
> > +             return -ENOMEM;
> > +
> > +     bitmap = bitmap_zalloc(size, GFP_KERNEL);
> > +     if (!bitmap) {
> > +             kfree(rqst_arr);
> > +             return -ENOMEM;
> > +     }
> > +
> > +     rqstor->req_arr = rqst_arr;
> > +     rqstor->req_bitmap = bitmap;
> > +     rqstor->size = size;
> > +     rqstor->next_request_id = 0;
> > +     spin_lock_init(&rqstor->req_lock);
> > +
> > +     return 0;
> > +}
> > +
> > +/*
> > + * vmbus_free_requestor - Frees memory allocated for @rqstor
> > + * @rqstor: Pointer to the requestor struct
> > + */
> > +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> > +{
> > +     kfree(rqstor->req_arr);
> > +     bitmap_free(rqstor->req_bitmap);
> > +}
> > +
> >  static int __vmbus_open(struct vmbus_channel *newchannel,
> >                      void *userdata, u32 userdatalen,
> >                      void (*onchannelcallback)(void *context), void *context)
> > @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
> >       if (newchannel->state != CHANNEL_OPEN_STATE)
> >               return -EINVAL;
> >
> > +     /* Create and init requestor */
> > +     if (newchannel->rqstor_size) {
> > +             if (vmbus_alloc_requestor(&newchannel->requestor, newchannel->rqstor_size))
> > +                     return -ENOMEM;
> > +     }
> > +
>
> Sorry for not noticing this in the last round: this infrastructure is
> initialized conditionally but used unconditionally.
>
> I can think of two options here:
>
>   1. Mandate rqstor_size to be non-zero. Always initialize this
>      infra.
>   2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
>      uninitialized state.
>
> For #2, you can simply check rqstor->size _before_ taking the lock
> (because it may be uninitialized, and the assumption is ->size will not
> change during the channel's lifetime, hence no lock is needed) and
> simply return the same value to the caller.
>
> Wei.

Right. I think option #2 would be preferable in this case, because #1 works
if we had a default non-zero size for cases where rqstor_size has not been
set to a non-zero value before calling vmbus_alloc_requestor(). For #2, what
do you mean by "same value"? I think we would need to return
VMBUS_RQST_ERROR if the size is 0, because otherwise we would be
returning the same guest memory address which we don't want to expose.

Andres.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* RE: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 21:51     ` Andres Beltran
@ 2020-06-29 21:56       ` Michael Kelley
  2020-06-29 22:09         ` Andres Beltran
  2020-06-29 22:15         ` Wei Liu
  2020-06-29 22:20       ` Wei Liu
  1 sibling, 2 replies; 16+ messages in thread
From: Michael Kelley @ 2020-06-29 21:56 UTC (permalink / raw)
  To: Andres Beltran, Wei Liu
  Cc: Andres Beltran, KY Srinivasan, Haiyang Zhang, Stephen Hemminger,
	linux-hyperv, linux-kernel, Andrea Parri

From: Andres Beltran <lkmlabelt@gmail.com> Sent: Monday, June 29, 2020 2:51 PM
> 
> On Mon, Jun 29, 2020 at 4:46 PM Wei Liu <wei.liu@kernel.org> wrote:
> >
> > On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> > > Currently, VMbus drivers use pointers into guest memory as request IDs
> > > for interactions with Hyper-V. To be more robust in the face of errors
> > > or malicious behavior from a compromised Hyper-V, avoid exposing
> > > guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> > > bad request ID that is then treated as the address of a guest data
> > > structure with no validation. Instead, encapsulate these memory
> > > addresses and provide small integers as request IDs.
> > >
> > > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> > > ---
> > > Changes in v2:
> > >       - Get rid of "rqstor" variable in __vmbus_open().
> > >
> > >  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
> > >  include/linux/hyperv.h |  21 ++++++
> > >  2 files changed, 167 insertions(+)
> > >
> > > diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> > > index 3ebda7707e46..c89d57d0c2d2 100644
> > > --- a/drivers/hv/channel.c
> > > +++ b/drivers/hv/channel.c
> > > @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
> > >  }
> > >  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
> > >
> > > +/**
> > > + * request_arr_init - Allocates memory for the requestor array. Each slot
> > > + * keeps track of the next available slot in the array. Initially, each
> > > + * slot points to the next one (as in a Linked List). The last slot
> > > + * does not point to anything, so its value is U64_MAX by default.
> > > + * @size The size of the array
> > > + */
> > > +static u64 *request_arr_init(u32 size)
> > > +{
> > > +     int i;
> > > +     u64 *req_arr;
> > > +
> > > +     req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> > > +     if (!req_arr)
> > > +             return NULL;
> > > +
> > > +     for (i = 0; i < size - 1; i++)
> > > +             req_arr[i] = i + 1;
> > > +
> > > +     /* Last slot (no more available slots) */
> > > +     req_arr[i] = U64_MAX;
> > > +
> > > +     return req_arr;
> > > +}
> > > +
> > > +/*
> > > + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> > > + * Slot at index 0 is the first free slot.
> > > + * @size: Size of the requestor array
> > > + */
> > > +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> > > +{
> > > +     u64 *rqst_arr;
> > > +     unsigned long *bitmap;
> > > +
> > > +     rqst_arr = request_arr_init(size);
> > > +     if (!rqst_arr)
> > > +             return -ENOMEM;
> > > +
> > > +     bitmap = bitmap_zalloc(size, GFP_KERNEL);
> > > +     if (!bitmap) {
> > > +             kfree(rqst_arr);
> > > +             return -ENOMEM;
> > > +     }
> > > +
> > > +     rqstor->req_arr = rqst_arr;
> > > +     rqstor->req_bitmap = bitmap;
> > > +     rqstor->size = size;
> > > +     rqstor->next_request_id = 0;
> > > +     spin_lock_init(&rqstor->req_lock);
> > > +
> > > +     return 0;
> > > +}
> > > +
> > > +/*
> > > + * vmbus_free_requestor - Frees memory allocated for @rqstor
> > > + * @rqstor: Pointer to the requestor struct
> > > + */
> > > +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> > > +{
> > > +     kfree(rqstor->req_arr);
> > > +     bitmap_free(rqstor->req_bitmap);
> > > +}
> > > +
> > >  static int __vmbus_open(struct vmbus_channel *newchannel,
> > >                      void *userdata, u32 userdatalen,
> > >                      void (*onchannelcallback)(void *context), void *context)
> > > @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
> > >       if (newchannel->state != CHANNEL_OPEN_STATE)
> > >               return -EINVAL;
> > >
> > > +     /* Create and init requestor */
> > > +     if (newchannel->rqstor_size) {
> > > +             if (vmbus_alloc_requestor(&newchannel->requestor, newchannel-
> >rqstor_size))
> > > +                     return -ENOMEM;
> > > +     }
> > > +
> >
> > Sorry for not noticing this in the last round: this infrastructure is
> > initialized conditionally but used unconditionally.
> >
> > I can think of two options here:
> >
> >   1. Mandate rqstor_size to be non-zero. Always initialize this
> >      infra.
> >   2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
> >      uninitialized state.
> >
> > For #2, you can simply check rqstor->size _before_ taking the lock
> > (because it may be uninitialized, and the assumption is ->size will not
> > change during the channel's lifetime, hence no lock is needed) and
> > simply return the same value to the caller.
> >
> > Wei.
> 
> Right. I think option #2 would be preferable in this case, because #1 works
> if we had a default non-zero size for cases where rqstor_size has not been
> set to a non-zero value before calling vmbus_alloc_requestor(). For #2, what
> do you mean by "same value"? I think we would need to return
> VMBUS_RQST_ERROR if the size is 0, because otherwise we would be
> returning the same guest memory address which we don't want to expose.
> 

I'm not understanding the problem here.  Any VMbus driver that uses
this requestID allocation mechanism must set newchannel->rqstor_size
to a non-zero value.  But if a VMbus driver doesn't use the mechanism,
then newchannel->rqstor_size will default to zero, and the mechanism
will not be initialized for the channels used by that driver.  I think the
cleanup of the mechanism handles the case where it wasn't ever
initialized.  Or am I missing something?

Michael

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 21:56       ` Michael Kelley
@ 2020-06-29 22:09         ` Andres Beltran
  2020-06-29 22:15         ` Wei Liu
  1 sibling, 0 replies; 16+ messages in thread
From: Andres Beltran @ 2020-06-29 22:09 UTC (permalink / raw)
  To: Michael Kelley
  Cc: Wei Liu, Andres Beltran, KY Srinivasan, Haiyang Zhang,
	Stephen Hemminger, linux-hyperv, linux-kernel, Andrea Parri

On Mon, Jun 29, 2020 at 5:56 PM Michael Kelley <mikelley@microsoft.com> wrote:
> I'm not understanding the problem here.  Any VMbus driver that uses
> this requestID allocation mechanism must set newchannel->rqstor_size
> to a non-zero value.  But if a VMbus driver doesn't use the mechanism,
> then newchannel->rqstor_size will default to zero, and the mechanism
> will not be initialized for the channels used by that driver.  I think the
> cleanup of the mechanism handles the case where it wasn't ever
> initialized.  Or am I missing something?
>
> Michael

Yes, that is correct. I think the validation is necessary if there
exists an instance
where a driver call vmbus_next_request_id or vmbus_request_addr() with a rqstor
that has not been previously initialized. Currently, the rqstor
pointer is not being
validated in these 2 functions, because we assume that the driver has
initialized the
array with a non-zero value before calling next_id() or request_addr().

Andres.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 21:56       ` Michael Kelley
  2020-06-29 22:09         ` Andres Beltran
@ 2020-06-29 22:15         ` Wei Liu
  1 sibling, 0 replies; 16+ messages in thread
From: Wei Liu @ 2020-06-29 22:15 UTC (permalink / raw)
  To: Michael Kelley
  Cc: Andres Beltran, Wei Liu, Andres Beltran, KY Srinivasan,
	Haiyang Zhang, Stephen Hemminger, linux-hyperv, linux-kernel,
	Andrea Parri

On Mon, Jun 29, 2020 at 09:56:08PM +0000, Michael Kelley wrote:
> From: Andres Beltran <lkmlabelt@gmail.com> Sent: Monday, June 29, 2020 2:51 PM
> > 
> > On Mon, Jun 29, 2020 at 4:46 PM Wei Liu <wei.liu@kernel.org> wrote:
> > >
> > > On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> > > > Currently, VMbus drivers use pointers into guest memory as request IDs
> > > > for interactions with Hyper-V. To be more robust in the face of errors
> > > > or malicious behavior from a compromised Hyper-V, avoid exposing
> > > > guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> > > > bad request ID that is then treated as the address of a guest data
> > > > structure with no validation. Instead, encapsulate these memory
> > > > addresses and provide small integers as request IDs.
> > > >
> > > > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> > > > ---
> > > > Changes in v2:
> > > >       - Get rid of "rqstor" variable in __vmbus_open().
> > > >
> > > >  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
> > > >  include/linux/hyperv.h |  21 ++++++
> > > >  2 files changed, 167 insertions(+)
> > > >
> > > > diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> > > > index 3ebda7707e46..c89d57d0c2d2 100644
> > > > --- a/drivers/hv/channel.c
> > > > +++ b/drivers/hv/channel.c
> > > > @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
> > > >  }
> > > >  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
> > > >
> > > > +/**
> > > > + * request_arr_init - Allocates memory for the requestor array. Each slot
> > > > + * keeps track of the next available slot in the array. Initially, each
> > > > + * slot points to the next one (as in a Linked List). The last slot
> > > > + * does not point to anything, so its value is U64_MAX by default.
> > > > + * @size The size of the array
> > > > + */
> > > > +static u64 *request_arr_init(u32 size)
> > > > +{
> > > > +     int i;
> > > > +     u64 *req_arr;
> > > > +
> > > > +     req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> > > > +     if (!req_arr)
> > > > +             return NULL;
> > > > +
> > > > +     for (i = 0; i < size - 1; i++)
> > > > +             req_arr[i] = i + 1;
> > > > +
> > > > +     /* Last slot (no more available slots) */
> > > > +     req_arr[i] = U64_MAX;
> > > > +
> > > > +     return req_arr;
> > > > +}
> > > > +
> > > > +/*
> > > > + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> > > > + * Slot at index 0 is the first free slot.
> > > > + * @size: Size of the requestor array
> > > > + */
> > > > +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> > > > +{
> > > > +     u64 *rqst_arr;
> > > > +     unsigned long *bitmap;
> > > > +
> > > > +     rqst_arr = request_arr_init(size);
> > > > +     if (!rqst_arr)
> > > > +             return -ENOMEM;
> > > > +
> > > > +     bitmap = bitmap_zalloc(size, GFP_KERNEL);
> > > > +     if (!bitmap) {
> > > > +             kfree(rqst_arr);
> > > > +             return -ENOMEM;
> > > > +     }
> > > > +
> > > > +     rqstor->req_arr = rqst_arr;
> > > > +     rqstor->req_bitmap = bitmap;
> > > > +     rqstor->size = size;
> > > > +     rqstor->next_request_id = 0;
> > > > +     spin_lock_init(&rqstor->req_lock);
> > > > +
> > > > +     return 0;
> > > > +}
> > > > +
> > > > +/*
> > > > + * vmbus_free_requestor - Frees memory allocated for @rqstor
> > > > + * @rqstor: Pointer to the requestor struct
> > > > + */
> > > > +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> > > > +{
> > > > +     kfree(rqstor->req_arr);
> > > > +     bitmap_free(rqstor->req_bitmap);
> > > > +}
> > > > +
> > > >  static int __vmbus_open(struct vmbus_channel *newchannel,
> > > >                      void *userdata, u32 userdatalen,
> > > >                      void (*onchannelcallback)(void *context), void *context)
> > > > @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
> > > >       if (newchannel->state != CHANNEL_OPEN_STATE)
> > > >               return -EINVAL;
> > > >
> > > > +     /* Create and init requestor */
> > > > +     if (newchannel->rqstor_size) {
> > > > +             if (vmbus_alloc_requestor(&newchannel->requestor, newchannel-
> > >rqstor_size))
> > > > +                     return -ENOMEM;
> > > > +     }
> > > > +
> > >
> > > Sorry for not noticing this in the last round: this infrastructure is
> > > initialized conditionally but used unconditionally.
> > >
> > > I can think of two options here:
> > >
> > >   1. Mandate rqstor_size to be non-zero. Always initialize this
> > >      infra.
> > >   2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
> > >      uninitialized state.
> > >
> > > For #2, you can simply check rqstor->size _before_ taking the lock
> > > (because it may be uninitialized, and the assumption is ->size will not
> > > change during the channel's lifetime, hence no lock is needed) and
> > > simply return the same value to the caller.
> > >
> > > Wei.
> > 
> > Right. I think option #2 would be preferable in this case, because #1 works
> > if we had a default non-zero size for cases where rqstor_size has not been
> > set to a non-zero value before calling vmbus_alloc_requestor(). For #2, what
> > do you mean by "same value"? I think we would need to return
> > VMBUS_RQST_ERROR if the size is 0, because otherwise we would be
> > returning the same guest memory address which we don't want to expose.
> > 
> 
> I'm not understanding the problem here.  Any VMbus driver that uses
> this requestID allocation mechanism must set newchannel->rqstor_size
> to a non-zero value.  But if a VMbus driver doesn't use the mechanism,
> then newchannel->rqstor_size will default to zero, and the mechanism
> will not be initialized for the channels used by that driver.  I think the
> cleanup of the mechanism handles the case where it wasn't ever
> initialized.  Or am I missing something?
> 

It is not about the cleanup function -- it handles things correctly
because kfree etc can cope with NULL pointers.

I'm referring to vmbus_next_request_id and vmbus_request_addr. They are
called in later patches regardless of whether the infrastructure is
initialized or not.

That is problematic, because the first thing those functions do is to
acquire the spinlock, which is not guaranteed to be initialized -- it is
initialized in vmbus_alloc_requestor which is called conditionally.

Wei.

> Michael

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 21:51     ` Andres Beltran
  2020-06-29 21:56       ` Michael Kelley
@ 2020-06-29 22:20       ` Wei Liu
  2020-06-29 23:45         ` Andres Beltran
  1 sibling, 1 reply; 16+ messages in thread
From: Wei Liu @ 2020-06-29 22:20 UTC (permalink / raw)
  To: Andres Beltran
  Cc: Wei Liu, Andres Beltran, kys, haiyangz, sthemmin, linux-hyperv,
	linux-kernel, Michael Kelley, Andrea Parri

On Mon, Jun 29, 2020 at 05:51:05PM -0400, Andres Beltran wrote:
> On Mon, Jun 29, 2020 at 4:46 PM Wei Liu <wei.liu@kernel.org> wrote:
> >
> > On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> > > Currently, VMbus drivers use pointers into guest memory as request IDs
> > > for interactions with Hyper-V. To be more robust in the face of errors
> > > or malicious behavior from a compromised Hyper-V, avoid exposing
> > > guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> > > bad request ID that is then treated as the address of a guest data
> > > structure with no validation. Instead, encapsulate these memory
> > > addresses and provide small integers as request IDs.
> > >
> > > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> > > ---
> > > Changes in v2:
> > >       - Get rid of "rqstor" variable in __vmbus_open().
> > >
> > >  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
> > >  include/linux/hyperv.h |  21 ++++++
> > >  2 files changed, 167 insertions(+)
> > >
> > > diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> > > index 3ebda7707e46..c89d57d0c2d2 100644
> > > --- a/drivers/hv/channel.c
> > > +++ b/drivers/hv/channel.c
> > > @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
> > >  }
> > >  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
> > >
> > > +/**
> > > + * request_arr_init - Allocates memory for the requestor array. Each slot
> > > + * keeps track of the next available slot in the array. Initially, each
> > > + * slot points to the next one (as in a Linked List). The last slot
> > > + * does not point to anything, so its value is U64_MAX by default.
> > > + * @size The size of the array
> > > + */
> > > +static u64 *request_arr_init(u32 size)
> > > +{
> > > +     int i;
> > > +     u64 *req_arr;
> > > +
> > > +     req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> > > +     if (!req_arr)
> > > +             return NULL;
> > > +
> > > +     for (i = 0; i < size - 1; i++)
> > > +             req_arr[i] = i + 1;
> > > +
> > > +     /* Last slot (no more available slots) */
> > > +     req_arr[i] = U64_MAX;
> > > +
> > > +     return req_arr;
> > > +}
> > > +
> > > +/*
> > > + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> > > + * Slot at index 0 is the first free slot.
> > > + * @size: Size of the requestor array
> > > + */
> > > +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> > > +{
> > > +     u64 *rqst_arr;
> > > +     unsigned long *bitmap;
> > > +
> > > +     rqst_arr = request_arr_init(size);
> > > +     if (!rqst_arr)
> > > +             return -ENOMEM;
> > > +
> > > +     bitmap = bitmap_zalloc(size, GFP_KERNEL);
> > > +     if (!bitmap) {
> > > +             kfree(rqst_arr);
> > > +             return -ENOMEM;
> > > +     }
> > > +
> > > +     rqstor->req_arr = rqst_arr;
> > > +     rqstor->req_bitmap = bitmap;
> > > +     rqstor->size = size;
> > > +     rqstor->next_request_id = 0;
> > > +     spin_lock_init(&rqstor->req_lock);
> > > +
> > > +     return 0;
> > > +}
> > > +
> > > +/*
> > > + * vmbus_free_requestor - Frees memory allocated for @rqstor
> > > + * @rqstor: Pointer to the requestor struct
> > > + */
> > > +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> > > +{
> > > +     kfree(rqstor->req_arr);
> > > +     bitmap_free(rqstor->req_bitmap);
> > > +}
> > > +
> > >  static int __vmbus_open(struct vmbus_channel *newchannel,
> > >                      void *userdata, u32 userdatalen,
> > >                      void (*onchannelcallback)(void *context), void *context)
> > > @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
> > >       if (newchannel->state != CHANNEL_OPEN_STATE)
> > >               return -EINVAL;
> > >
> > > +     /* Create and init requestor */
> > > +     if (newchannel->rqstor_size) {
> > > +             if (vmbus_alloc_requestor(&newchannel->requestor, newchannel->rqstor_size))
> > > +                     return -ENOMEM;
> > > +     }
> > > +
> >
> > Sorry for not noticing this in the last round: this infrastructure is
> > initialized conditionally but used unconditionally.
> >
> > I can think of two options here:
> >
> >   1. Mandate rqstor_size to be non-zero. Always initialize this
> >      infra.
> >   2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
> >      uninitialized state.
> >
> > For #2, you can simply check rqstor->size _before_ taking the lock
> > (because it may be uninitialized, and the assumption is ->size will not
> > change during the channel's lifetime, hence no lock is needed) and
> > simply return the same value to the caller.
> >
> > Wei.
> 
> Right. I think option #2 would be preferable in this case, because #1 works
> if we had a default non-zero size for cases where rqstor_size has not been
> set to a non-zero value before calling vmbus_alloc_requestor(). For #2, what
> do you mean by "same value"? I think we would need to return
> VMBUS_RQST_ERROR if the size is 0, because otherwise we would be
> returning the same guest memory address which we don't want to expose.

By "same value", I meant reverting back to using guest memory address.
I thought downgrading gracefully is better than making the driver stop
working.

If exposing guest address is not acceptable, you can return
VMBUS_RQST_ERROR -- but at the point you may as well mandate requestor
infrastructure to be always initialized, right?

Wei.

> 
> Andres.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 3/3] hv_netvsc: Use vmbus_requestor to generate transaction IDs for VMBus hardening
  2020-06-29 21:33   ` Haiyang Zhang
@ 2020-06-29 22:26     ` Wei Liu
  0 siblings, 0 replies; 16+ messages in thread
From: Wei Liu @ 2020-06-29 22:26 UTC (permalink / raw)
  To: Haiyang Zhang
  Cc: Andres Beltran, KY Srinivasan, Stephen Hemminger, wei.liu,
	linux-hyperv, linux-kernel, Michael Kelley, parri.andrea,
	David S . Miller, Jakub Kicinski, netdev

On Mon, Jun 29, 2020 at 09:33:15PM +0000, Haiyang Zhang wrote:
> 
> 
> > -----Original Message-----
> > From: Andres Beltran <lkmlabelt@gmail.com>
> > Sent: Monday, June 29, 2020 4:02 PM
> > To: KY Srinivasan <kys@microsoft.com>; Haiyang Zhang
> > <haiyangz@microsoft.com>; Stephen Hemminger <sthemmin@microsoft.com>;
> > wei.liu@kernel.org
> > Cc: linux-hyperv@vger.kernel.org; linux-kernel@vger.kernel.org; Michael
> > Kelley <mikelley@microsoft.com>; parri.andrea@gmail.com; Andres Beltran
> > <lkmlabelt@gmail.com>; David S . Miller <davem@davemloft.net>; Jakub
> > Kicinski <kuba@kernel.org>; netdev@vger.kernel.org
> > Subject: [PATCH v2 3/3] hv_netvsc: Use vmbus_requestor to generate
> > transaction IDs for VMBus hardening
> > 
> > Currently, pointers to guest memory are passed to Hyper-V as
> > transaction IDs in netvsc. In the face of errors or malicious
> > behavior in Hyper-V, netvsc should not expose or trust the transaction
> > IDs returned by Hyper-V to be valid guest memory addresses. Instead,
> > use small integers generated by vmbus_requestor as requests
> > (transaction) IDs.
> > 
> > Cc: David S. Miller <davem@davemloft.net>
> > Cc: Jakub Kicinski <kuba@kernel.org>
> > Cc: netdev@vger.kernel.org
> > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> 
> Reviewed-by: Haiyang Zhang <haiyangz@microsoft.com>
> 
> 

Thanks Haiyang for reviewing.

David and Jakub:

This patch depends on the first patch. I intend to pick up this patch
via hyperv.git. This makes life easier for all of us. Let me know if you
disagree.

Wei.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 22:20       ` Wei Liu
@ 2020-06-29 23:45         ` Andres Beltran
  2020-06-30 10:09           ` Wei Liu
  0 siblings, 1 reply; 16+ messages in thread
From: Andres Beltran @ 2020-06-29 23:45 UTC (permalink / raw)
  To: Wei Liu
  Cc: Andres Beltran, KY Srinivasan, Haiyang Zhang, Stephen Hemminger,
	linux-hyperv, linux-kernel, Michael Kelley, Andrea Parri

On Mon, Jun 29, 2020 at 6:20 PM Wei Liu <wei.liu@kernel.org> wrote:
>
> On Mon, Jun 29, 2020 at 05:51:05PM -0400, Andres Beltran wrote:
> > On Mon, Jun 29, 2020 at 4:46 PM Wei Liu <wei.liu@kernel.org> wrote:
> > >
> > > On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> > > > Currently, VMbus drivers use pointers into guest memory as request IDs
> > > > for interactions with Hyper-V. To be more robust in the face of errors
> > > > or malicious behavior from a compromised Hyper-V, avoid exposing
> > > > guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> > > > bad request ID that is then treated as the address of a guest data
> > > > structure with no validation. Instead, encapsulate these memory
> > > > addresses and provide small integers as request IDs.
> > > >
> > > > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> > > > ---
> > > > Changes in v2:
> > > >       - Get rid of "rqstor" variable in __vmbus_open().
> > > >
> > > >  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
> > > >  include/linux/hyperv.h |  21 ++++++
> > > >  2 files changed, 167 insertions(+)
> > > >
> > > > diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> > > > index 3ebda7707e46..c89d57d0c2d2 100644
> > > > --- a/drivers/hv/channel.c
> > > > +++ b/drivers/hv/channel.c
> > > > @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
> > > >  }
> > > >  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
> > > >
> > > > +/**
> > > > + * request_arr_init - Allocates memory for the requestor array. Each slot
> > > > + * keeps track of the next available slot in the array. Initially, each
> > > > + * slot points to the next one (as in a Linked List). The last slot
> > > > + * does not point to anything, so its value is U64_MAX by default.
> > > > + * @size The size of the array
> > > > + */
> > > > +static u64 *request_arr_init(u32 size)
> > > > +{
> > > > +     int i;
> > > > +     u64 *req_arr;
> > > > +
> > > > +     req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> > > > +     if (!req_arr)
> > > > +             return NULL;
> > > > +
> > > > +     for (i = 0; i < size - 1; i++)
> > > > +             req_arr[i] = i + 1;
> > > > +
> > > > +     /* Last slot (no more available slots) */
> > > > +     req_arr[i] = U64_MAX;
> > > > +
> > > > +     return req_arr;
> > > > +}
> > > > +
> > > > +/*
> > > > + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> > > > + * Slot at index 0 is the first free slot.
> > > > + * @size: Size of the requestor array
> > > > + */
> > > > +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> > > > +{
> > > > +     u64 *rqst_arr;
> > > > +     unsigned long *bitmap;
> > > > +
> > > > +     rqst_arr = request_arr_init(size);
> > > > +     if (!rqst_arr)
> > > > +             return -ENOMEM;
> > > > +
> > > > +     bitmap = bitmap_zalloc(size, GFP_KERNEL);
> > > > +     if (!bitmap) {
> > > > +             kfree(rqst_arr);
> > > > +             return -ENOMEM;
> > > > +     }
> > > > +
> > > > +     rqstor->req_arr = rqst_arr;
> > > > +     rqstor->req_bitmap = bitmap;
> > > > +     rqstor->size = size;
> > > > +     rqstor->next_request_id = 0;
> > > > +     spin_lock_init(&rqstor->req_lock);
> > > > +
> > > > +     return 0;
> > > > +}
> > > > +
> > > > +/*
> > > > + * vmbus_free_requestor - Frees memory allocated for @rqstor
> > > > + * @rqstor: Pointer to the requestor struct
> > > > + */
> > > > +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> > > > +{
> > > > +     kfree(rqstor->req_arr);
> > > > +     bitmap_free(rqstor->req_bitmap);
> > > > +}
> > > > +
> > > >  static int __vmbus_open(struct vmbus_channel *newchannel,
> > > >                      void *userdata, u32 userdatalen,
> > > >                      void (*onchannelcallback)(void *context), void *context)
> > > > @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
> > > >       if (newchannel->state != CHANNEL_OPEN_STATE)
> > > >               return -EINVAL;
> > > >
> > > > +     /* Create and init requestor */
> > > > +     if (newchannel->rqstor_size) {
> > > > +             if (vmbus_alloc_requestor(&newchannel->requestor, newchannel->rqstor_size))
> > > > +                     return -ENOMEM;
> > > > +     }
> > > > +
> > >
> > > Sorry for not noticing this in the last round: this infrastructure is
> > > initialized conditionally but used unconditionally.
> > >
> > > I can think of two options here:
> > >
> > >   1. Mandate rqstor_size to be non-zero. Always initialize this
> > >      infra.
> > >   2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
> > >      uninitialized state.
> > >
> > > For #2, you can simply check rqstor->size _before_ taking the lock
> > > (because it may be uninitialized, and the assumption is ->size will not
> > > change during the channel's lifetime, hence no lock is needed) and
> > > simply return the same value to the caller.
> > >
> > > Wei.
> >
> > Right. I think option #2 would be preferable in this case, because #1 works
> > if we had a default non-zero size for cases where rqstor_size has not been
> > set to a non-zero value before calling vmbus_alloc_requestor(). For #2, what
> > do you mean by "same value"? I think we would need to return
> > VMBUS_RQST_ERROR if the size is 0, because otherwise we would be
> > returning the same guest memory address which we don't want to expose.
>
> By "same value", I meant reverting back to using guest memory address.
> I thought downgrading gracefully is better than making the driver stop
> working.
>
> If exposing guest address is not acceptable, you can return
> VMBUS_RQST_ERROR -- but at the point you may as well mandate requestor
> infrastructure to be always initialized, right?
>

If the allocation of the requestor fails during runtime, vmbus_open()
fails too and therefore,
the channel and the requestor will not be created. So, the 2 functions
(next_id, requestor_addr)
will never get called, right? The only case in which we hit this edge
case is if a driver is using this
mechanism with a size of 0 (i.e. rqstor_size is not set to a non-zero
value before calling vmbus_open()),
but that would be more like a coding bug. So, I think it would be
better to return VMBUS_RQST_ERROR
as a way to assert that there is a bug in the code. I don't know if
I'm missing something here.

Andres.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-29 23:45         ` Andres Beltran
@ 2020-06-30 10:09           ` Wei Liu
  2020-06-30 10:17             ` Wei Liu
  0 siblings, 1 reply; 16+ messages in thread
From: Wei Liu @ 2020-06-30 10:09 UTC (permalink / raw)
  To: Andres Beltran
  Cc: Wei Liu, Andres Beltran, KY Srinivasan, Haiyang Zhang,
	Stephen Hemminger, linux-hyperv, linux-kernel, Michael Kelley,
	Andrea Parri

On Mon, Jun 29, 2020 at 07:45:00PM -0400, Andres Beltran wrote:
> On Mon, Jun 29, 2020 at 6:20 PM Wei Liu <wei.liu@kernel.org> wrote:
> >
> > On Mon, Jun 29, 2020 at 05:51:05PM -0400, Andres Beltran wrote:
> > > On Mon, Jun 29, 2020 at 4:46 PM Wei Liu <wei.liu@kernel.org> wrote:
> > > >
> > > > On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> > > > > Currently, VMbus drivers use pointers into guest memory as request IDs
> > > > > for interactions with Hyper-V. To be more robust in the face of errors
> > > > > or malicious behavior from a compromised Hyper-V, avoid exposing
> > > > > guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> > > > > bad request ID that is then treated as the address of a guest data
> > > > > structure with no validation. Instead, encapsulate these memory
> > > > > addresses and provide small integers as request IDs.
> > > > >
> > > > > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> > > > > ---
> > > > > Changes in v2:
> > > > >       - Get rid of "rqstor" variable in __vmbus_open().
> > > > >
> > > > >  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
> > > > >  include/linux/hyperv.h |  21 ++++++
> > > > >  2 files changed, 167 insertions(+)
> > > > >
> > > > > diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> > > > > index 3ebda7707e46..c89d57d0c2d2 100644
> > > > > --- a/drivers/hv/channel.c
> > > > > +++ b/drivers/hv/channel.c
> > > > > @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
> > > > >  }
> > > > >  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
> > > > >
> > > > > +/**
> > > > > + * request_arr_init - Allocates memory for the requestor array. Each slot
> > > > > + * keeps track of the next available slot in the array. Initially, each
> > > > > + * slot points to the next one (as in a Linked List). The last slot
> > > > > + * does not point to anything, so its value is U64_MAX by default.
> > > > > + * @size The size of the array
> > > > > + */
> > > > > +static u64 *request_arr_init(u32 size)
> > > > > +{
> > > > > +     int i;
> > > > > +     u64 *req_arr;
> > > > > +
> > > > > +     req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> > > > > +     if (!req_arr)
> > > > > +             return NULL;
> > > > > +
> > > > > +     for (i = 0; i < size - 1; i++)
> > > > > +             req_arr[i] = i + 1;
> > > > > +
> > > > > +     /* Last slot (no more available slots) */
> > > > > +     req_arr[i] = U64_MAX;
> > > > > +
> > > > > +     return req_arr;
> > > > > +}
> > > > > +
> > > > > +/*
> > > > > + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> > > > > + * Slot at index 0 is the first free slot.
> > > > > + * @size: Size of the requestor array
> > > > > + */
> > > > > +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> > > > > +{
> > > > > +     u64 *rqst_arr;
> > > > > +     unsigned long *bitmap;
> > > > > +
> > > > > +     rqst_arr = request_arr_init(size);
> > > > > +     if (!rqst_arr)
> > > > > +             return -ENOMEM;
> > > > > +
> > > > > +     bitmap = bitmap_zalloc(size, GFP_KERNEL);
> > > > > +     if (!bitmap) {
> > > > > +             kfree(rqst_arr);
> > > > > +             return -ENOMEM;
> > > > > +     }
> > > > > +
> > > > > +     rqstor->req_arr = rqst_arr;
> > > > > +     rqstor->req_bitmap = bitmap;
> > > > > +     rqstor->size = size;
> > > > > +     rqstor->next_request_id = 0;
> > > > > +     spin_lock_init(&rqstor->req_lock);
> > > > > +
> > > > > +     return 0;
> > > > > +}
> > > > > +
> > > > > +/*
> > > > > + * vmbus_free_requestor - Frees memory allocated for @rqstor
> > > > > + * @rqstor: Pointer to the requestor struct
> > > > > + */
> > > > > +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> > > > > +{
> > > > > +     kfree(rqstor->req_arr);
> > > > > +     bitmap_free(rqstor->req_bitmap);
> > > > > +}
> > > > > +
> > > > >  static int __vmbus_open(struct vmbus_channel *newchannel,
> > > > >                      void *userdata, u32 userdatalen,
> > > > >                      void (*onchannelcallback)(void *context), void *context)
> > > > > @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
> > > > >       if (newchannel->state != CHANNEL_OPEN_STATE)
> > > > >               return -EINVAL;
> > > > >
> > > > > +     /* Create and init requestor */
> > > > > +     if (newchannel->rqstor_size) {
> > > > > +             if (vmbus_alloc_requestor(&newchannel->requestor, newchannel->rqstor_size))
> > > > > +                     return -ENOMEM;
> > > > > +     }
> > > > > +
> > > >
> > > > Sorry for not noticing this in the last round: this infrastructure is
> > > > initialized conditionally but used unconditionally.
> > > >
> > > > I can think of two options here:
> > > >
> > > >   1. Mandate rqstor_size to be non-zero. Always initialize this
> > > >      infra.
> > > >   2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
> > > >      uninitialized state.
> > > >
> > > > For #2, you can simply check rqstor->size _before_ taking the lock
> > > > (because it may be uninitialized, and the assumption is ->size will not
> > > > change during the channel's lifetime, hence no lock is needed) and
> > > > simply return the same value to the caller.
> > > >
> > > > Wei.
> > >
> > > Right. I think option #2 would be preferable in this case, because #1 works
> > > if we had a default non-zero size for cases where rqstor_size has not been
> > > set to a non-zero value before calling vmbus_alloc_requestor(). For #2, what
> > > do you mean by "same value"? I think we would need to return
> > > VMBUS_RQST_ERROR if the size is 0, because otherwise we would be
> > > returning the same guest memory address which we don't want to expose.
> >
> > By "same value", I meant reverting back to using guest memory address.
> > I thought downgrading gracefully is better than making the driver stop
> > working.
> >
> > If exposing guest address is not acceptable, you can return
> > VMBUS_RQST_ERROR -- but at the point you may as well mandate requestor
> > infrastructure to be always initialized, right?
> >
> 
> If the allocation of the requestor fails during runtime, vmbus_open()
> fails too and therefore,
> the channel and the requestor will not be created. So, the 2 functions
> (next_id, requestor_addr)
> will never get called, right? The only case in which we hit this edge
> case is if a driver is using this
> mechanism with a size of 0 (i.e. rqstor_size is not set to a non-zero
> value before calling vmbus_open()),

Right. This is what I was getting at. Setting the size to 0 effectively
makes the driver unusable. And per your design, it should be considered
a bug.

> but that would be more like a coding bug. So, I think it would be
> better to return VMBUS_RQST_ERROR
> as a way to assert that there is a bug in the code. I don't know if
> I'm missing something here.

Since we know setting size to 0 is a bug, you can actually just do the
following in the __vmbus_open function instead of going through all the
initialization with the knowledge vmbus_next_request_id & co will fail.

    /* Create and init requestor */
    if (!newchannel->rqstor_size)
          return an error to caller here

    vmbus_alloc_requestor(...);


Wei.

> 
> Andres.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-30 10:09           ` Wei Liu
@ 2020-06-30 10:17             ` Wei Liu
  2020-06-30 10:48               ` Wei Liu
  0 siblings, 1 reply; 16+ messages in thread
From: Wei Liu @ 2020-06-30 10:17 UTC (permalink / raw)
  To: Andres Beltran
  Cc: Wei Liu, Andres Beltran, KY Srinivasan, Haiyang Zhang,
	Stephen Hemminger, linux-hyperv, linux-kernel, Michael Kelley,
	Andrea Parri

On Tue, Jun 30, 2020 at 10:09:45AM +0000, Wei Liu wrote:
> On Mon, Jun 29, 2020 at 07:45:00PM -0400, Andres Beltran wrote:
> > On Mon, Jun 29, 2020 at 6:20 PM Wei Liu <wei.liu@kernel.org> wrote:
> > >
> > > On Mon, Jun 29, 2020 at 05:51:05PM -0400, Andres Beltran wrote:
> > > > On Mon, Jun 29, 2020 at 4:46 PM Wei Liu <wei.liu@kernel.org> wrote:
> > > > >
> > > > > On Mon, Jun 29, 2020 at 04:02:25PM -0400, Andres Beltran wrote:
> > > > > > Currently, VMbus drivers use pointers into guest memory as request IDs
> > > > > > for interactions with Hyper-V. To be more robust in the face of errors
> > > > > > or malicious behavior from a compromised Hyper-V, avoid exposing
> > > > > > guest memory addresses to Hyper-V. Also avoid Hyper-V giving back a
> > > > > > bad request ID that is then treated as the address of a guest data
> > > > > > structure with no validation. Instead, encapsulate these memory
> > > > > > addresses and provide small integers as request IDs.
> > > > > >
> > > > > > Signed-off-by: Andres Beltran <lkmlabelt@gmail.com>
> > > > > > ---
> > > > > > Changes in v2:
> > > > > >       - Get rid of "rqstor" variable in __vmbus_open().
> > > > > >
> > > > > >  drivers/hv/channel.c   | 146 +++++++++++++++++++++++++++++++++++++++++
> > > > > >  include/linux/hyperv.h |  21 ++++++
> > > > > >  2 files changed, 167 insertions(+)
> > > > > >
> > > > > > diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
> > > > > > index 3ebda7707e46..c89d57d0c2d2 100644
> > > > > > --- a/drivers/hv/channel.c
> > > > > > +++ b/drivers/hv/channel.c
> > > > > > @@ -112,6 +112,70 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel,
> > > > > >  }
> > > > > >  EXPORT_SYMBOL_GPL(vmbus_alloc_ring);
> > > > > >
> > > > > > +/**
> > > > > > + * request_arr_init - Allocates memory for the requestor array. Each slot
> > > > > > + * keeps track of the next available slot in the array. Initially, each
> > > > > > + * slot points to the next one (as in a Linked List). The last slot
> > > > > > + * does not point to anything, so its value is U64_MAX by default.
> > > > > > + * @size The size of the array
> > > > > > + */
> > > > > > +static u64 *request_arr_init(u32 size)
> > > > > > +{
> > > > > > +     int i;
> > > > > > +     u64 *req_arr;
> > > > > > +
> > > > > > +     req_arr = kcalloc(size, sizeof(u64), GFP_KERNEL);
> > > > > > +     if (!req_arr)
> > > > > > +             return NULL;
> > > > > > +
> > > > > > +     for (i = 0; i < size - 1; i++)
> > > > > > +             req_arr[i] = i + 1;
> > > > > > +
> > > > > > +     /* Last slot (no more available slots) */
> > > > > > +     req_arr[i] = U64_MAX;
> > > > > > +
> > > > > > +     return req_arr;
> > > > > > +}
> > > > > > +
> > > > > > +/*
> > > > > > + * vmbus_alloc_requestor - Initializes @rqstor's fields.
> > > > > > + * Slot at index 0 is the first free slot.
> > > > > > + * @size: Size of the requestor array
> > > > > > + */
> > > > > > +static int vmbus_alloc_requestor(struct vmbus_requestor *rqstor, u32 size)
> > > > > > +{
> > > > > > +     u64 *rqst_arr;
> > > > > > +     unsigned long *bitmap;
> > > > > > +
> > > > > > +     rqst_arr = request_arr_init(size);
> > > > > > +     if (!rqst_arr)
> > > > > > +             return -ENOMEM;
> > > > > > +
> > > > > > +     bitmap = bitmap_zalloc(size, GFP_KERNEL);
> > > > > > +     if (!bitmap) {
> > > > > > +             kfree(rqst_arr);
> > > > > > +             return -ENOMEM;
> > > > > > +     }
> > > > > > +
> > > > > > +     rqstor->req_arr = rqst_arr;
> > > > > > +     rqstor->req_bitmap = bitmap;
> > > > > > +     rqstor->size = size;
> > > > > > +     rqstor->next_request_id = 0;
> > > > > > +     spin_lock_init(&rqstor->req_lock);
> > > > > > +
> > > > > > +     return 0;
> > > > > > +}
> > > > > > +
> > > > > > +/*
> > > > > > + * vmbus_free_requestor - Frees memory allocated for @rqstor
> > > > > > + * @rqstor: Pointer to the requestor struct
> > > > > > + */
> > > > > > +static void vmbus_free_requestor(struct vmbus_requestor *rqstor)
> > > > > > +{
> > > > > > +     kfree(rqstor->req_arr);
> > > > > > +     bitmap_free(rqstor->req_bitmap);
> > > > > > +}
> > > > > > +
> > > > > >  static int __vmbus_open(struct vmbus_channel *newchannel,
> > > > > >                      void *userdata, u32 userdatalen,
> > > > > >                      void (*onchannelcallback)(void *context), void *context)
> > > > > > @@ -132,6 +196,12 @@ static int __vmbus_open(struct vmbus_channel *newchannel,
> > > > > >       if (newchannel->state != CHANNEL_OPEN_STATE)
> > > > > >               return -EINVAL;
> > > > > >
> > > > > > +     /* Create and init requestor */
> > > > > > +     if (newchannel->rqstor_size) {
> > > > > > +             if (vmbus_alloc_requestor(&newchannel->requestor, newchannel->rqstor_size))
> > > > > > +                     return -ENOMEM;
> > > > > > +     }
> > > > > > +
> > > > >
> > > > > Sorry for not noticing this in the last round: this infrastructure is
> > > > > initialized conditionally but used unconditionally.
> > > > >
> > > > > I can think of two options here:
> > > > >
> > > > >   1. Mandate rqstor_size to be non-zero. Always initialize this
> > > > >      infra.
> > > > >   2. Modify vmbus_next_request_id and vmbus_request_addr to deal with
> > > > >      uninitialized state.
> > > > >
> > > > > For #2, you can simply check rqstor->size _before_ taking the lock
> > > > > (because it may be uninitialized, and the assumption is ->size will not
> > > > > change during the channel's lifetime, hence no lock is needed) and
> > > > > simply return the same value to the caller.
> > > > >
> > > > > Wei.
> > > >
> > > > Right. I think option #2 would be preferable in this case, because #1 works
> > > > if we had a default non-zero size for cases where rqstor_size has not been
> > > > set to a non-zero value before calling vmbus_alloc_requestor(). For #2, what
> > > > do you mean by "same value"? I think we would need to return
> > > > VMBUS_RQST_ERROR if the size is 0, because otherwise we would be
> > > > returning the same guest memory address which we don't want to expose.
> > >
> > > By "same value", I meant reverting back to using guest memory address.
> > > I thought downgrading gracefully is better than making the driver stop
> > > working.
> > >
> > > If exposing guest address is not acceptable, you can return
> > > VMBUS_RQST_ERROR -- but at the point you may as well mandate requestor
> > > infrastructure to be always initialized, right?
> > >
> > 
> > If the allocation of the requestor fails during runtime, vmbus_open()
> > fails too and therefore,
> > the channel and the requestor will not be created. So, the 2 functions
> > (next_id, requestor_addr)
> > will never get called, right? The only case in which we hit this edge
> > case is if a driver is using this
> > mechanism with a size of 0 (i.e. rqstor_size is not set to a non-zero
> > value before calling vmbus_open()),
> 
> Right. This is what I was getting at. Setting the size to 0 effectively
> makes the driver unusable. And per your design, it should be considered
> a bug.
> 
> > but that would be more like a coding bug. So, I think it would be
> > better to return VMBUS_RQST_ERROR
> > as a way to assert that there is a bug in the code. I don't know if
> > I'm missing something here.
> 
> Since we know setting size to 0 is a bug, you can actually just do the
> following in the __vmbus_open function instead of going through all the
> initialization with the knowledge vmbus_next_request_id & co will fail.
> 
>     /* Create and init requestor */
>     if (!newchannel->rqstor_size)
>           return an error to caller here
> 
>     vmbus_alloc_requestor(...);

And obviously you should check vmbus_alloc_requestor's return value
somehow. You get the idea...

Wei.

> 
> 
> Wei.
> 
> > 
> > Andres.

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [PATCH v2 1/3] Drivers: hv: vmbus: Add vmbus_requestor data structure for VMBus hardening
  2020-06-30 10:17             ` Wei Liu
@ 2020-06-30 10:48               ` Wei Liu
  0 siblings, 0 replies; 16+ messages in thread
From: Wei Liu @ 2020-06-30 10:48 UTC (permalink / raw)
  To: Andres Beltran
  Cc: Wei Liu, Andres Beltran, KY Srinivasan, Haiyang Zhang,
	Stephen Hemminger, linux-hyperv, linux-kernel, Michael Kelley,
	Andrea Parri

On Tue, Jun 30, 2020 at 10:17:36AM +0000, Wei Liu wrote:
[...]
> > > 
> > > If the allocation of the requestor fails during runtime, vmbus_open()
> > > fails too and therefore,
> > > the channel and the requestor will not be created. So, the 2 functions
> > > (next_id, requestor_addr)
> > > will never get called, right? The only case in which we hit this edge
> > > case is if a driver is using this
> > > mechanism with a size of 0 (i.e. rqstor_size is not set to a non-zero
> > > value before calling vmbus_open()),
> > 
> > Right. This is what I was getting at. Setting the size to 0 effectively
> > makes the driver unusable. And per your design, it should be considered
> > a bug.
> > 
> > > but that would be more like a coding bug. So, I think it would be
> > > better to return VMBUS_RQST_ERROR
> > > as a way to assert that there is a bug in the code. I don't know if
> > > I'm missing something here.
> > 
> > Since we know setting size to 0 is a bug, you can actually just do the
> > following in the __vmbus_open function instead of going through all the
> > initialization with the knowledge vmbus_next_request_id & co will fail.
> > 
> >     /* Create and init requestor */
> >     if (!newchannel->rqstor_size)
> >           return an error to caller here
> > 
> >     vmbus_alloc_requestor(...);
> 
> And obviously you should check vmbus_alloc_requestor's return value
> somehow. You get the idea...
> 

Andrea pointed out that I missed one critical aspect of the design --
not all drivers are supposed to use this infrastructure. That's contrary
to my original understanding, in which all drivers are supposed to use
this infrastructure.

With that in mind, it is okay to only initialize the infra only when
->rqstor_size is not zero. Then you just handle the edge case in
vmbus_next_request_id & co.

Wei.

> Wei.
> 
> > 
> > 
> > Wei.
> > 
> > > 
> > > Andres.

^ permalink raw reply	[flat|nested] 16+ messages in thread

end of thread, back to index

Thread overview: 16+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-06-29 20:02 [PATCH v2 0/3] Drivers: hv: vmbus: vmbus_requestor data structure for VMBus hardening Andres Beltran
2020-06-29 20:02 ` [PATCH v2 1/3] Drivers: hv: vmbus: Add " Andres Beltran
2020-06-29 20:46   ` Wei Liu
2020-06-29 21:51     ` Andres Beltran
2020-06-29 21:56       ` Michael Kelley
2020-06-29 22:09         ` Andres Beltran
2020-06-29 22:15         ` Wei Liu
2020-06-29 22:20       ` Wei Liu
2020-06-29 23:45         ` Andres Beltran
2020-06-30 10:09           ` Wei Liu
2020-06-30 10:17             ` Wei Liu
2020-06-30 10:48               ` Wei Liu
2020-06-29 20:02 ` [PATCH v2 2/3] scsi: storvsc: Use vmbus_requestor to generate transaction IDs " Andres Beltran
2020-06-29 20:02 ` [PATCH v2 3/3] hv_netvsc: " Andres Beltran
2020-06-29 21:33   ` Haiyang Zhang
2020-06-29 22:26     ` Wei Liu

Linux-HyperV Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/linux-hyperv/0 linux-hyperv/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 linux-hyperv linux-hyperv/ https://lore.kernel.org/linux-hyperv \
		linux-hyperv@vger.kernel.org
	public-inbox-index linux-hyperv

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.linux-hyperv


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git