Commit f56dbdda authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'hyperv-next-signed-20220528' of... 

Merge tag 'hyperv-next-signed-20220528' of git://git.kernel.org/pub/scm/linux/kernel/git/hyperv/linux

Pull hyperv updates from Wei Liu:

 - Harden hv_sock driver (Andrea Parri)

 - Harden Hyper-V PCI driver (Andrea Parri)

 - Fix multi-MSI for Hyper-V PCI driver (Jeffrey Hugo)

 - Fix Hyper-V PCI to reduce boot time (Dexuan Cui)

 - Remove code for long EOL'ed Hyper-V versions (Michael Kelley, Saurabh
   Sengar)

 - Fix balloon driver error handling (Shradha Gupta)

 - Fix a typo in vmbus driver (Julia Lawall)

 - Ignore vmbus IMC device (Michael Kelley)

 - Add a new error message to Hyper-V DRM driver (Saurabh Sengar)

* tag 'hyperv-next-signed-20220528' of git://git.kernel.org/pub/scm/linux/kernel/git/hyperv/linux: (28 commits)
  hv_balloon: Fix balloon_probe() and balloon_remove() error handling
  scsi: storvsc: Removing Pre Win8 related logic
  Drivers: hv: vmbus: fix typo in comment
  PCI: hv: Fix synchronization between channel callback and hv_pci_bus_exit()
  PCI: hv: Add validation for untrusted Hyper-V values
  PCI: hv: Fix interrupt mapping for multi-MSI
  PCI: hv: Reuse existing IRTE allocation in compose_msi_msg()
  drm/hyperv: Remove support for Hyper-V 2008 and 2008R2/Win7
  video: hyperv_fb: Remove support for Hyper-V 2008 and 2008R2/Win7
  scsi: storvsc: Remove support for Hyper-V 2008 and 2008R2/Win7
  Drivers: hv: vmbus: Remove support for Hyper-V 2008 and Hyper-V 2008R2/Win7
  x86/hyperv: Disable hardlockup detector by default in Hyper-V guests
  drm/hyperv: Add error message for fb size greater than allocated
  PCI: hv: Do not set PCI_COMMAND_MEMORY to reduce VM boot time
  PCI: hv: Fix hv_arch_irq_unmask() for multi-MSI
  Drivers: hv: vmbus: Refactor the ring-buffer iterator functions
  Drivers: hv: vmbus: Accept hv_sock offers in isolated guests
  hv_sock: Add validation for untrusted Hyper-V values
  hv_sock: Copy packets sent by Hyper-V out of the ring buffer
  hv_sock: Check hv_pkt_iter_first_raw()'s return value
  ...
parents 6112bd00 d27423bf

arch/x86/kernel/cpu/mshyperv.c

+2 −0
Original line number Diff line number Diff line
@@ -457,6 +457,8 @@ static void __init ms_hyperv_init_platform(void) 
	 */

	if (!(ms_hyperv.features & HV_ACCESS_TSC_INVARIANT))

		mark_tsc_unstable("running on Hyper-V");



	hardlockup_detector_disable();

}



static bool __init ms_hyperv_x2apic_available(void)

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

+4 −1
Original line number Diff line number Diff line
@@ -123,8 +123,11 @@ static int hyperv_pipe_check(struct drm_simple_display_pipe *pipe, 
	if (fb->format->format != DRM_FORMAT_XRGB8888)

		return -EINVAL;



	if (fb->pitches[0] * fb->height > hv->fb_size)

	if (fb->pitches[0] * fb->height > hv->fb_size) {

		drm_err(&hv->dev, "fb size requested by %s for %dX%d (pitch %d) greater than %ld\n",

			current->comm, fb->width, fb->height, fb->pitches[0], hv->fb_size);

		return -EINVAL;

	}



	return 0;

}

drivers/gpu/drm/hyperv/hyperv_drm_proto.c

+7 −16
Original line number Diff line number Diff line
@@ -18,16 +18,16 @@ 
#define SYNTHVID_VERSION(major, minor) ((minor) << 16 | (major))

#define SYNTHVID_VER_GET_MAJOR(ver) (ver & 0x0000ffff)

#define SYNTHVID_VER_GET_MINOR(ver) ((ver & 0xffff0000) >> 16)



/* Support for VERSION_WIN7 is removed. #define is retained for reference. */

#define SYNTHVID_VERSION_WIN7 SYNTHVID_VERSION(3, 0)

#define SYNTHVID_VERSION_WIN8 SYNTHVID_VERSION(3, 2)

#define SYNTHVID_VERSION_WIN10 SYNTHVID_VERSION(3, 5)



#define SYNTHVID_DEPTH_WIN7 16

#define SYNTHVID_DEPTH_WIN8 32

#define SYNTHVID_FB_SIZE_WIN7 (4 * 1024 * 1024)

#define SYNTHVID_WIDTH_WIN8 1600

#define SYNTHVID_HEIGHT_WIN8 1200

#define SYNTHVID_FB_SIZE_WIN8 (8 * 1024 * 1024)

#define SYNTHVID_WIDTH_MAX_WIN7 1600

#define SYNTHVID_HEIGHT_MAX_WIN7 1200



enum pipe_msg_type {

	PIPE_MSG_INVALID,
@@ -496,12 +496,6 @@ int hyperv_connect_vsp(struct hv_device *hdev) 
	case VERSION_WIN8:

	case VERSION_WIN8_1:

		ret = hyperv_negotiate_version(hdev, SYNTHVID_VERSION_WIN8);

		if (!ret)

			break;

		fallthrough;

	case VERSION_WS2008:

	case VERSION_WIN7:

		ret = hyperv_negotiate_version(hdev, SYNTHVID_VERSION_WIN7);

		break;

	default:

		ret = hyperv_negotiate_version(hdev, SYNTHVID_VERSION_WIN10);
@@ -513,9 +507,6 @@ int hyperv_connect_vsp(struct hv_device *hdev) 
		goto error;

	}



	if (hv->synthvid_version == SYNTHVID_VERSION_WIN7)

		hv->screen_depth = SYNTHVID_DEPTH_WIN7;

	else

	hv->screen_depth = SYNTHVID_DEPTH_WIN8;



	if (hyperv_version_ge(hv->synthvid_version, SYNTHVID_VERSION_WIN10)) {
@@ -523,8 +514,8 @@ int hyperv_connect_vsp(struct hv_device *hdev) 
		if (ret)

			drm_err(dev, "Failed to get supported resolution from host, use default\n");

	} else {

		hv->screen_width_max = SYNTHVID_WIDTH_MAX_WIN7;

		hv->screen_height_max = SYNTHVID_HEIGHT_MAX_WIN7;

		hv->screen_width_max = SYNTHVID_WIDTH_WIN8;

		hv->screen_height_max = SYNTHVID_HEIGHT_WIN8;

	}



	hv->mmio_megabytes = hdev->channel->offermsg.offer.mmio_megabytes;

drivers/hv/channel.c

+86 −30
Original line number Diff line number Diff line
@@ -1022,11 +1022,13 @@ void vmbus_close(struct vmbus_channel *channel) 
EXPORT_SYMBOL_GPL(vmbus_close);



/**

 * vmbus_sendpacket() - Send the specified buffer on the given channel

 * vmbus_sendpacket_getid() - Send the specified buffer on the given channel

 * @channel: Pointer to vmbus_channel structure

 * @buffer: Pointer to the buffer you want to send the data from.

 * @bufferlen: Maximum size of what the buffer holds.

 * @requestid: Identifier of the request

 * @trans_id: Identifier of the transaction associated to this request, if

 *            the send is successful; undefined, otherwise.

 * @type: Type of packet that is being sent e.g. negotiate, time

 *	  packet etc.

 * @flags: 0 or VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
@@ -1036,8 +1038,8 @@ EXPORT_SYMBOL_GPL(vmbus_close); 
 *

 * Mainly used by Hyper-V drivers.

 */

int vmbus_sendpacket(struct vmbus_channel *channel, void *buffer,

			   u32 bufferlen, u64 requestid,

int vmbus_sendpacket_getid(struct vmbus_channel *channel, void *buffer,

			   u32 bufferlen, u64 requestid, u64 *trans_id,

			   enum vmbus_packet_type type, u32 flags)

{

	struct vmpacket_descriptor desc;
@@ -1063,7 +1065,31 @@ int vmbus_sendpacket(struct vmbus_channel *channel, void *buffer, 
	bufferlist[2].iov_base = &aligned_data;

	bufferlist[2].iov_len = (packetlen_aligned - packetlen);



	return hv_ringbuffer_write(channel, bufferlist, num_vecs, requestid);

	return hv_ringbuffer_write(channel, bufferlist, num_vecs, requestid, trans_id);

}

EXPORT_SYMBOL(vmbus_sendpacket_getid);



/**

 * vmbus_sendpacket() - Send the specified buffer on the given channel

 * @channel: Pointer to vmbus_channel structure

 * @buffer: Pointer to the buffer you want to send the data from.

 * @bufferlen: Maximum size of what the buffer holds.

 * @requestid: Identifier of the request

 * @type: Type of packet that is being sent e.g. negotiate, time

 *	  packet etc.

 * @flags: 0 or VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED

 *

 * Sends data in @buffer directly to Hyper-V via the vmbus.

 * This will send the data unparsed to Hyper-V.

 *

 * Mainly used by Hyper-V drivers.

 */

int vmbus_sendpacket(struct vmbus_channel *channel, void *buffer,

		     u32 bufferlen, u64 requestid,

		     enum vmbus_packet_type type, u32 flags)

{

	return vmbus_sendpacket_getid(channel, buffer, bufferlen,

				      requestid, NULL, type, flags);

}

EXPORT_SYMBOL(vmbus_sendpacket);
@@ -1122,7 +1148,7 @@ int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel, 
	bufferlist[2].iov_base = &aligned_data;

	bufferlist[2].iov_len = (packetlen_aligned - packetlen);



	return hv_ringbuffer_write(channel, bufferlist, 3, requestid);

	return hv_ringbuffer_write(channel, bufferlist, 3, requestid, NULL);

}

EXPORT_SYMBOL_GPL(vmbus_sendpacket_pagebuffer);
@@ -1160,7 +1186,7 @@ int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel, 
	bufferlist[2].iov_base = &aligned_data;

	bufferlist[2].iov_len = (packetlen_aligned - packetlen);



	return hv_ringbuffer_write(channel, bufferlist, 3, requestid);

	return hv_ringbuffer_write(channel, bufferlist, 3, requestid, NULL);

}

EXPORT_SYMBOL_GPL(vmbus_sendpacket_mpb_desc);
@@ -1226,12 +1252,12 @@ u64 vmbus_next_request_id(struct vmbus_channel *channel, u64 rqst_addr) 
	if (!channel->rqstor_size)

		return VMBUS_NO_RQSTOR;



	spin_lock_irqsave(&rqstor->req_lock, flags);

	lock_requestor(channel, flags);

	current_id = rqstor->next_request_id;



	/* Requestor array is full */

	if (current_id >= rqstor->size) {

		spin_unlock_irqrestore(&rqstor->req_lock, flags);

		unlock_requestor(channel, flags);

		return VMBUS_RQST_ERROR;

	}
@@ -1241,27 +1267,23 @@ u64 vmbus_next_request_id(struct vmbus_channel *channel, u64 rqst_addr) 
	/* The already held spin lock provides atomicity */

	bitmap_set(rqstor->req_bitmap, current_id, 1);



	spin_unlock_irqrestore(&rqstor->req_lock, flags);

	unlock_requestor(channel, flags);



	/*

	 * Cannot return an ID of 0, which is reserved for an unsolicited

	 * message from Hyper-V.

	 * message from Hyper-V; Hyper-V does not acknowledge (respond to)

	 * VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED requests with ID of

	 * 0 sent by the guest.

	 */

	return current_id + 1;

}

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.

 * @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_channel *channel, u64 trans_id)

/* As in vmbus_request_addr_match() but without the requestor lock */

u64 __vmbus_request_addr_match(struct vmbus_channel *channel, u64 trans_id,

			       u64 rqst_addr)

{

	struct vmbus_requestor *rqstor = &channel->requestor;

	unsigned long flags;

	u64 req_addr;



	/* Check rqstor has been initialized */
@@ -1270,27 +1292,61 @@ u64 vmbus_request_addr(struct vmbus_channel *channel, u64 trans_id) 


	/* Hyper-V can send an unsolicited message with ID of 0 */

	if (!trans_id)

		return trans_id;



	spin_lock_irqsave(&rqstor->req_lock, flags);

		return VMBUS_RQST_ERROR;



	/* Data corresponding to trans_id is stored at trans_id - 1 */

	trans_id--;



	/* Invalid trans_id */

	if (trans_id >= rqstor->size || !test_bit(trans_id, rqstor->req_bitmap)) {

		spin_unlock_irqrestore(&rqstor->req_lock, flags);

	if (trans_id >= rqstor->size || !test_bit(trans_id, rqstor->req_bitmap))

		return VMBUS_RQST_ERROR;

	}



	req_addr = rqstor->req_arr[trans_id];

	if (rqst_addr == VMBUS_RQST_ADDR_ANY || req_addr == rqst_addr) {

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

	}



	return req_addr;

}

EXPORT_SYMBOL_GPL(__vmbus_request_addr_match);



/*

 * vmbus_request_addr_match - Clears/removes @trans_id from the @channel's

 * requestor, provided the memory address stored at @trans_id equals @rqst_addr

 * (or provided @rqst_addr matches the sentinel value VMBUS_RQST_ADDR_ANY).

 *

 * Returns the memory address stored at @trans_id, or VMBUS_RQST_ERROR if

 * @trans_id is not contained in the requestor.

 *

 * Acquires and releases the requestor spin lock.

 */

u64 vmbus_request_addr_match(struct vmbus_channel *channel, u64 trans_id,

			     u64 rqst_addr)

{

	unsigned long flags;

	u64 req_addr;



	lock_requestor(channel, flags);

	req_addr = __vmbus_request_addr_match(channel, trans_id, rqst_addr);

	unlock_requestor(channel, flags);



	spin_unlock_irqrestore(&rqstor->req_lock, flags);

	return req_addr;

}

EXPORT_SYMBOL_GPL(vmbus_request_addr_match);



/*

 * vmbus_request_addr - Returns the memory address stored at @trans_id

 * in @rqstor. Uses a spin lock to avoid race conditions.

 * @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_channel *channel, u64 trans_id)

{

	return vmbus_request_addr_match(channel, trans_id, VMBUS_RQST_ADDR_ANY);

}

EXPORT_SYMBOL_GPL(vmbus_request_addr);

drivers/hv/channel_mgmt.c

+19 −21
Original line number Diff line number Diff line
@@ -152,6 +152,7 @@ static const struct { 
	{ HV_AVMA1_GUID },

	{ HV_AVMA2_GUID },

	{ HV_RDV_GUID	},

	{ HV_IMC_GUID	},

};



/*
@@ -442,7 +443,7 @@ void hv_process_channel_removal(struct vmbus_channel *channel) 
	/*

	 * Upon suspend, an in-use hv_sock channel is removed from the array of

	 * channels and the relid is invalidated.  After hibernation, when the

	 * user-space appplication destroys the channel, it's unnecessary and

	 * user-space application destroys the channel, it's unnecessary and

	 * unsafe to remove the channel from the array of channels.  See also

	 * the inline comments before the call of vmbus_release_relid() below.

	 */
@@ -713,15 +714,13 @@ static bool hv_cpuself_used(u32 cpu, struct vmbus_channel *chn) 
static int next_numa_node_id;



/*

 * Starting with Win8, we can statically distribute the incoming

 * channel interrupt load by binding a channel to VCPU.

 * We can statically distribute the incoming channel interrupt load

 * by binding a channel to VCPU.

 *

 * For pre-win8 hosts or non-performance critical channels we assign the

 * VMBUS_CONNECT_CPU.

 *

 * Starting with win8, performance critical channels will be distributed

 * evenly among all the available NUMA nodes.  Once the node is assigned,

 * we will assign the CPU based on a simple round robin scheme.

 * For non-performance critical channels we assign the VMBUS_CONNECT_CPU.

 * Performance critical channels will be distributed evenly among all

 * the available NUMA nodes.  Once the node is assigned, we will assign

 * the CPU based on a simple round robin scheme.

 */

static void init_vp_index(struct vmbus_channel *channel)

{
@@ -732,13 +731,10 @@ static void init_vp_index(struct vmbus_channel *channel) 
	u32 target_cpu;

	int numa_node;



	if ((vmbus_proto_version == VERSION_WS2008) ||

	    (vmbus_proto_version == VERSION_WIN7) || (!perf_chn) ||

	if (!perf_chn ||

	    !alloc_cpumask_var(&available_mask, GFP_KERNEL)) {

		/*

		 * Prior to win8, all channel interrupts are

		 * delivered on VMBUS_CONNECT_CPU.

		 * Also if the channel is not a performance critical

		 * If the channel is not a performance critical

		 * channel, bind it to VMBUS_CONNECT_CPU.

		 * In case alloc_cpumask_var() fails, bind it to

		 * VMBUS_CONNECT_CPU.
@@ -931,11 +927,9 @@ static void vmbus_setup_channel_state(struct vmbus_channel *channel, 
	 */

	channel->sig_event = VMBUS_EVENT_CONNECTION_ID;



	if (vmbus_proto_version != VERSION_WS2008) {

	channel->is_dedicated_interrupt =

			(offer->is_dedicated_interrupt != 0);

	channel->sig_event = offer->connection_id;

	}



	memcpy(&channel->offermsg, offer,

	       sizeof(struct vmbus_channel_offer_channel));
@@ -975,13 +969,17 @@ find_primary_channel_by_offer(const struct vmbus_channel_offer_channel *offer) 
	return channel;

}



static bool vmbus_is_valid_device(const guid_t *guid)

static bool vmbus_is_valid_offer(const struct vmbus_channel_offer_channel *offer)

{

	const guid_t *guid = &offer->offer.if_type;

	u16 i;



	if (!hv_is_isolation_supported())

		return true;



	if (is_hvsock_offer(offer))

		return true;



	for (i = 0; i < ARRAY_SIZE(vmbus_devs); i++) {

		if (guid_equal(guid, &vmbus_devs[i].guid))

			return vmbus_devs[i].allowed_in_isolated;
@@ -1003,7 +1001,7 @@ static void vmbus_onoffer(struct vmbus_channel_message_header *hdr) 


	trace_vmbus_onoffer(offer);



	if (!vmbus_is_valid_device(&offer->offer.if_type)) {

	if (!vmbus_is_valid_offer(offer)) {

		pr_err_ratelimited("Invalid offer %d from the host supporting isolation\n",

				   offer->child_relid);

		atomic_dec(&vmbus_connection.offer_in_progress);