Allow killing a process waiting for a VM bus message reply

Signed-off-by: Iouri Tarassov <iourit@linux.microsoft.com>

Author: Iouri Tarassov

drivers/hv/dxgkrnl/dxgadapter.c

@@ -1045,6 +1045,8 @@ void dxgprocess_adapter_destroy(struct dxgprocess_adapter *adapter_info)
 		list_del(&device->device_list_entry);
 		device->device_list_entry.next = NULL;
 		mutex_unlock(&adapter_info->device_list_mutex);
+		dxgvmb_send_flush_device(device,
+			DXGDEVICE_FLUSHSCHEDULER_DEVICE_TERMINATE);
 		dxgdevice_destroy(device);
 		mutex_lock(&adapter_info->device_list_mutex);
 	}

drivers/hv/dxgkrnl/dxgkrnl.h

@@ -63,6 +63,11 @@ struct dxgk_device_types {
 	u32 virtual_monitor_device:1;
 };
 
+enum dxgdevice_flushschedulerreason
+{
+	DXGDEVICE_FLUSHSCHEDULER_DEVICE_TERMINATE = 4,
+};
+
 enum dxgobjectstate {
 	DXGOBJECTSTATE_CREATED,
 	DXGOBJECTSTATE_ACTIVE,
@@ -757,6 +762,8 @@ struct d3dkmthandle dxgvmb_send_create_device(struct dxgadapter *adapter,
 int dxgvmb_send_destroy_device(struct dxgadapter *adapter,
 			       struct dxgprocess *process,
 			       struct d3dkmthandle h);
+int dxgvmb_send_flush_device(struct dxgdevice *device,
+			     enum dxgdevice_flushschedulerreason reason);
 struct d3dkmthandle
 dxgvmb_send_create_context(struct dxgadapter *adapter,
 			   struct dxgprocess *process,

drivers/hv/dxgkrnl/dxgmodule.c

@@ -23,7 +23,7 @@
 struct dxgglobal *dxgglobal;
 struct device *dxgglobaldev;
 
-#define DXGKRNL_VERSION			0x2202
+#define DXGKRNL_VERSION			0x2216
 #define PCI_VENDOR_ID_MICROSOFT		0x1414
 #define PCI_DEVICE_ID_VIRTUAL_RENDER	0x008E
 

drivers/hv/dxgkrnl/dxgvmbus.c

@@ -37,6 +37,7 @@ struct dxgvmbuspacket {
 	void *buffer;
 	u32 buffer_length;
 	int status;
+	bool completed;
 };
 
 struct dxgvmb_ext_header {
@@ -354,6 +355,7 @@ void process_completion_packet(struct dxgvmbuschannel *channel,
 		if (desc->trans_id == entry->request_id) {
 			packet = entry;
 			list_del(&packet->packet_list_entry);
+			packet->completed = true;
 			break;
 		}
 	}
@@ -436,6 +438,7 @@ int dxgvmb_send_sync_msg(struct dxgvmbuschannel *channel,
 	packet->buffer = result;
 	packet->buffer_length = result_size;
 	packet->status = 0;
+	packet->completed = false;
 	spin_lock_irq(&channel->packet_list_mutex);
 	list_add_tail(&packet->packet_list_entry, &channel->packet_list_head);
 	spin_unlock_irq(&channel->packet_list_mutex);
@@ -452,7 +455,15 @@ int dxgvmb_send_sync_msg(struct dxgvmbuschannel *channel,
 	}
 
 	dev_dbg(dxgglobaldev, "waiting completion: %llu", packet->request_id);
-	wait_for_completion(&packet->wait);
+	ret = wait_for_completion_killable(&packet->wait);
+	if (ret) {
+		pr_err("wait_for_complition failed: %x", ret);
+		spin_lock_irq(&channel->packet_list_mutex);
+		if (!packet->completed)
+			list_del(&packet->packet_list_entry);
+		spin_unlock_irq(&channel->packet_list_mutex);
+		goto cleanup;
+	}
 	dev_dbg(dxgglobaldev, "completion done: %llu %x",
 		packet->request_id, packet->status);
 	ret = packet->status;
@@ -1071,6 +1082,32 @@ int dxgvmb_send_destroy_device(struct dxgadapter *adapter,
 	return ret;
 }
 
+int dxgvmb_send_flush_device(struct dxgdevice *device,
+			     enum dxgdevice_flushschedulerreason reason)
+{
+	int ret;
+	struct dxgkvmb_command_flushdevice *command;
+	struct dxgvmbusmsg msg = {.hdr = NULL};
+	struct dxgprocess *process = device->process;
+
+	ret = init_message(&msg, device->adapter, process, sizeof(*command));
+	if (ret)
+		goto cleanup;
+	command = (void *)msg.msg;
+
+	command_vgpu_to_host_init2(&command->hdr, DXGK_VMBCOMMAND_FLUSHDEVICE,
+				   process->host_handle);
+	command->device = device->handle;
+	command->reason = reason;
+
+	ret = dxgvmb_send_sync_msg_ntstatus(msg.channel, msg.hdr, msg.size);
+cleanup:
+	free_message(&msg, process);
+	if (ret)
+		dev_dbg(dxgglobaldev, "err: %s %d", __func__, ret);
+	return ret;
+}
+
 struct d3dkmthandle
 dxgvmb_send_create_context(struct dxgadapter *adapter,
 			   struct dxgprocess *process,

drivers/hv/dxgkrnl/dxgvmbus.h

@@ -396,6 +396,13 @@ struct dxgkvmb_command_destroydevice {
 	struct d3dkmthandle		device;
 };
 
+struct dxgkvmb_command_flushdevice
+{
+	struct dxgkvmb_command_vgpu_to_host	hdr;
+	struct d3dkmthandle			device;
+	enum dxgdevice_flushschedulerreason	reason;
+};
+
 struct dxgkvmb_command_makeresident {
 	struct dxgkvmb_command_vgpu_to_host hdr;
 	struct d3dkmthandle		device;

drivers/hv/dxgkrnl/ioctl.c

@@ -3594,7 +3594,7 @@ dxgk_wait_sync_object_cpu(struct dxgprocess *process, void *__user inargs)
 					async_host_event = NULL;
 				} else {
 					pr_err("Invalid event type");
-					DXGKRNL_ASSERT(FALSE);
+					DXGKRNL_ASSERT(0);
 				}
 			}
 		}
@@ -4395,81 +4395,6 @@ dxgk_flush_heap_transitions(struct dxgprocess *process, void *__user inargs)
 	return ret;
 }
 
-#ifdef DEBUG
-static int handle_table_escape(struct dxgprocess *process,
-				struct d3dkmt_escape *args,
-				struct d3dkmt_ht_desc *cmdin)
-{
-	int ret = 0;
-	struct d3dkmt_ht_desc cmd;
-	struct hmgrtable *table;
-
-	mutex_lock(&process->process_mutex);
-	cmd = *cmdin;
-	if (cmd.index >= 2) {
-		pr_err("invalid table index");
-		ret = -EINVAL;
-		goto cleanup;
-	}
-	table = process->test_handle_table[cmd.index];
-	if (table == NULL) {
-		table = vzalloc(sizeof(*table));
-		if (table == NULL) {
-			ret = -EINVAL;
-			goto cleanup;
-		}
-		hmgrtable_init(table, process);
-		process->test_handle_table[cmd.index] = table;
-	}
-	switch (cmd.command) {
-	case D3DKMT_HT_COMMAND_ALLOC:
-		cmd.handle = hmgrtable_alloc_handle_safe(table, cmd.object,
-							 (enum hmgrentry_type)
-							 cmd.object_type, true);
-		ret = copy_to_user(args->priv_drv_data, &cmd, sizeof(cmd));
-		if (ret)
-			ret = -EINVAL;
-		break;
-	case D3DKMT_HT_COMMAND_FREE:
-		hmgrtable_free_handle_safe(table,
-					   (enum hmgrentry_type)cmd.object_type,
-					   cmd.handle);
-		break;
-	case D3DKMT_HT_COMMAND_ASSIGN:
-		ret = hmgrtable_assign_handle_safe(table, cmd.object,
-					(enum hmgrentry_type)cmd.object_type,
-					cmd.handle);
-		break;
-	case D3DKMT_HT_COMMAND_GET:
-		hmgrtable_lock(table, DXGLOCK_SHARED);
-		cmd.object = hmgrtable_get_object_by_type(table,
-							  (enum hmgrentry_type)
-							  cmd.object_type,
-							  cmd.handle);
-		hmgrtable_unlock(table, DXGLOCK_SHARED);
-		ret = copy_to_user(args->priv_drv_data, &cmd, sizeof(cmd));
-		if (ret)
-			ret = -EINVAL;
-		break;
-	case D3DKMT_HT_COMMAND_DESTROY:
-		if (table) {
-			hmgrtable_destroy(table);
-			vfree(table);
-		}
-		process->test_handle_table[cmd.index] = NULL;
-		break;
-	default:
-		ret = -EINVAL;
-		pr_err("unknoen handle table command");
-		break;
-	}
-
-cleanup:
-	mutex_unlock(&process->process_mutex);
-	return ret;
-}
-#endif /* DEBUG */
-
 static int
 dxgk_escape(struct dxgprocess *process, void *__user inargs)
 {
@@ -4497,30 +4422,6 @@ dxgk_escape(struct dxgprocess *process, void *__user inargs)
 	}
 	adapter_locked = true;
 
-#ifdef DEBUG
-	if (args.type == D3DKMT_ESCAPE_DRT_TEST) {
-		struct d3dkmt_ht_desc drtcmd;
-
-		if (args.priv_drv_data_size >= sizeof(drtcmd)) {
-			ret = copy_from_user(&drtcmd,
-					     args.priv_drv_data,
-					     sizeof(drtcmd));
-			if (ret) {
-				ret = -EINVAL;
-				goto cleanup;
-			}
-			if (drtcmd.head.command ==
-			    D3DKMT_DRT_TEST_COMMAND_HANDLETABLE) {
-				dxgadapter_release_lock_shared(adapter);
-				adapter_locked = false;
-				ret = handle_table_escape(process, &args,
-							  &drtcmd);
-				goto cleanup;
-			}
-		}
-	}
-#endif /* DEBUG */
-
 	args.adapter = adapter->host_handle;
 	ret = dxgvmb_send_escape(process, adapter, &args);