xref: /openbmc/linux/drivers/virt/acrn/irqfd.c (revision fbeac3df)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * ACRN HSM irqfd: use eventfd objects to inject virtual interrupts
4  *
5  * Copyright (C) 2020 Intel Corporation. All rights reserved.
6  *
7  * Authors:
8  *	Shuo Liu <shuo.a.liu@intel.com>
9  *	Yakui Zhao <yakui.zhao@intel.com>
10  */
11 
12 #include <linux/eventfd.h>
13 #include <linux/file.h>
14 #include <linux/poll.h>
15 #include <linux/slab.h>
16 
17 #include "acrn_drv.h"
18 
19 static LIST_HEAD(acrn_irqfd_clients);
20 
21 /**
22  * struct hsm_irqfd - Properties of HSM irqfd
23  * @vm:		Associated VM pointer
24  * @wait:	Entry of wait-queue
25  * @shutdown:	Async shutdown work
26  * @eventfd:	Associated eventfd
27  * @list:	Entry within &acrn_vm.irqfds of irqfds of a VM
28  * @pt:		Structure for select/poll on the associated eventfd
29  * @msi:	MSI data
30  */
31 struct hsm_irqfd {
32 	struct acrn_vm		*vm;
33 	wait_queue_entry_t	wait;
34 	struct work_struct	shutdown;
35 	struct eventfd_ctx	*eventfd;
36 	struct list_head	list;
37 	poll_table		pt;
38 	struct acrn_msi_entry	msi;
39 };
40 
acrn_irqfd_inject(struct hsm_irqfd * irqfd)41 static void acrn_irqfd_inject(struct hsm_irqfd *irqfd)
42 {
43 	struct acrn_vm *vm = irqfd->vm;
44 
45 	acrn_msi_inject(vm, irqfd->msi.msi_addr,
46 			irqfd->msi.msi_data);
47 }
48 
hsm_irqfd_shutdown(struct hsm_irqfd * irqfd)49 static void hsm_irqfd_shutdown(struct hsm_irqfd *irqfd)
50 {
51 	u64 cnt;
52 
53 	lockdep_assert_held(&irqfd->vm->irqfds_lock);
54 
55 	/* remove from wait queue */
56 	list_del_init(&irqfd->list);
57 	eventfd_ctx_remove_wait_queue(irqfd->eventfd, &irqfd->wait, &cnt);
58 	eventfd_ctx_put(irqfd->eventfd);
59 	kfree(irqfd);
60 }
61 
hsm_irqfd_shutdown_work(struct work_struct * work)62 static void hsm_irqfd_shutdown_work(struct work_struct *work)
63 {
64 	struct hsm_irqfd *irqfd;
65 	struct acrn_vm *vm;
66 
67 	irqfd = container_of(work, struct hsm_irqfd, shutdown);
68 	vm = irqfd->vm;
69 	mutex_lock(&vm->irqfds_lock);
70 	if (!list_empty(&irqfd->list))
71 		hsm_irqfd_shutdown(irqfd);
72 	mutex_unlock(&vm->irqfds_lock);
73 }
74 
75 /* Called with wqh->lock held and interrupts disabled */
hsm_irqfd_wakeup(wait_queue_entry_t * wait,unsigned int mode,int sync,void * key)76 static int hsm_irqfd_wakeup(wait_queue_entry_t *wait, unsigned int mode,
77 			    int sync, void *key)
78 {
79 	unsigned long poll_bits = (unsigned long)key;
80 	struct hsm_irqfd *irqfd;
81 	struct acrn_vm *vm;
82 
83 	irqfd = container_of(wait, struct hsm_irqfd, wait);
84 	vm = irqfd->vm;
85 	if (poll_bits & POLLIN)
86 		/* An event has been signaled, inject an interrupt */
87 		acrn_irqfd_inject(irqfd);
88 
89 	if (poll_bits & POLLHUP)
90 		/* Do shutdown work in thread to hold wqh->lock */
91 		queue_work(vm->irqfd_wq, &irqfd->shutdown);
92 
93 	return 0;
94 }
95 
hsm_irqfd_poll_func(struct file * file,wait_queue_head_t * wqh,poll_table * pt)96 static void hsm_irqfd_poll_func(struct file *file, wait_queue_head_t *wqh,
97 				poll_table *pt)
98 {
99 	struct hsm_irqfd *irqfd;
100 
101 	irqfd = container_of(pt, struct hsm_irqfd, pt);
102 	add_wait_queue(wqh, &irqfd->wait);
103 }
104 
105 /*
106  * Assign an eventfd to a VM and create a HSM irqfd associated with the
107  * eventfd. The properties of the HSM irqfd are built from a &struct
108  * acrn_irqfd.
109  */
acrn_irqfd_assign(struct acrn_vm * vm,struct acrn_irqfd * args)110 static int acrn_irqfd_assign(struct acrn_vm *vm, struct acrn_irqfd *args)
111 {
112 	struct eventfd_ctx *eventfd = NULL;
113 	struct hsm_irqfd *irqfd, *tmp;
114 	__poll_t events;
115 	struct fd f;
116 	int ret = 0;
117 
118 	irqfd = kzalloc(sizeof(*irqfd), GFP_KERNEL);
119 	if (!irqfd)
120 		return -ENOMEM;
121 
122 	irqfd->vm = vm;
123 	memcpy(&irqfd->msi, &args->msi, sizeof(args->msi));
124 	INIT_LIST_HEAD(&irqfd->list);
125 	INIT_WORK(&irqfd->shutdown, hsm_irqfd_shutdown_work);
126 
127 	f = fdget(args->fd);
128 	if (!f.file) {
129 		ret = -EBADF;
130 		goto out;
131 	}
132 
133 	eventfd = eventfd_ctx_fileget(f.file);
134 	if (IS_ERR(eventfd)) {
135 		ret = PTR_ERR(eventfd);
136 		goto fail;
137 	}
138 
139 	irqfd->eventfd = eventfd;
140 
141 	/*
142 	 * Install custom wake-up handling to be notified whenever underlying
143 	 * eventfd is signaled.
144 	 */
145 	init_waitqueue_func_entry(&irqfd->wait, hsm_irqfd_wakeup);
146 	init_poll_funcptr(&irqfd->pt, hsm_irqfd_poll_func);
147 
148 	mutex_lock(&vm->irqfds_lock);
149 	list_for_each_entry(tmp, &vm->irqfds, list) {
150 		if (irqfd->eventfd != tmp->eventfd)
151 			continue;
152 		ret = -EBUSY;
153 		mutex_unlock(&vm->irqfds_lock);
154 		goto fail;
155 	}
156 	list_add_tail(&irqfd->list, &vm->irqfds);
157 	mutex_unlock(&vm->irqfds_lock);
158 
159 	/* Check the pending event in this stage */
160 	events = vfs_poll(f.file, &irqfd->pt);
161 
162 	if (events & EPOLLIN)
163 		acrn_irqfd_inject(irqfd);
164 
165 	fdput(f);
166 	return 0;
167 fail:
168 	if (eventfd && !IS_ERR(eventfd))
169 		eventfd_ctx_put(eventfd);
170 
171 	fdput(f);
172 out:
173 	kfree(irqfd);
174 	return ret;
175 }
176 
acrn_irqfd_deassign(struct acrn_vm * vm,struct acrn_irqfd * args)177 static int acrn_irqfd_deassign(struct acrn_vm *vm,
178 			       struct acrn_irqfd *args)
179 {
180 	struct hsm_irqfd *irqfd, *tmp;
181 	struct eventfd_ctx *eventfd;
182 
183 	eventfd = eventfd_ctx_fdget(args->fd);
184 	if (IS_ERR(eventfd))
185 		return PTR_ERR(eventfd);
186 
187 	mutex_lock(&vm->irqfds_lock);
188 	list_for_each_entry_safe(irqfd, tmp, &vm->irqfds, list) {
189 		if (irqfd->eventfd == eventfd) {
190 			hsm_irqfd_shutdown(irqfd);
191 			break;
192 		}
193 	}
194 	mutex_unlock(&vm->irqfds_lock);
195 	eventfd_ctx_put(eventfd);
196 
197 	return 0;
198 }
199 
acrn_irqfd_config(struct acrn_vm * vm,struct acrn_irqfd * args)200 int acrn_irqfd_config(struct acrn_vm *vm, struct acrn_irqfd *args)
201 {
202 	int ret;
203 
204 	if (args->flags & ACRN_IRQFD_FLAG_DEASSIGN)
205 		ret = acrn_irqfd_deassign(vm, args);
206 	else
207 		ret = acrn_irqfd_assign(vm, args);
208 
209 	return ret;
210 }
211 
acrn_irqfd_init(struct acrn_vm * vm)212 int acrn_irqfd_init(struct acrn_vm *vm)
213 {
214 	INIT_LIST_HEAD(&vm->irqfds);
215 	mutex_init(&vm->irqfds_lock);
216 	vm->irqfd_wq = alloc_workqueue("acrn_irqfd-%u", 0, 0, vm->vmid);
217 	if (!vm->irqfd_wq)
218 		return -ENOMEM;
219 
220 	dev_dbg(acrn_dev.this_device, "VM %u irqfd init.\n", vm->vmid);
221 	return 0;
222 }
223 
acrn_irqfd_deinit(struct acrn_vm * vm)224 void acrn_irqfd_deinit(struct acrn_vm *vm)
225 {
226 	struct hsm_irqfd *irqfd, *next;
227 
228 	dev_dbg(acrn_dev.this_device, "VM %u irqfd deinit.\n", vm->vmid);
229 	destroy_workqueue(vm->irqfd_wq);
230 	mutex_lock(&vm->irqfds_lock);
231 	list_for_each_entry_safe(irqfd, next, &vm->irqfds, list)
232 		hsm_irqfd_shutdown(irqfd);
233 	mutex_unlock(&vm->irqfds_lock);
234 }
235