xref: /qemu/include/hw/xen/xen_backend_ops.h (revision 83ecdb18) 
1 /*
2  * QEMU Xen backend support
3  *
4  * Copyright © 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
5  *
6  * Authors: David Woodhouse <dwmw2@infradead.org>
7  *
8  * This work is licensed under the terms of the GNU GPL, version 2 or later.
9  * See the COPYING file in the top-level directory.
10  */
11 
12 #ifndef QEMU_XEN_BACKEND_OPS_H
13 #define QEMU_XEN_BACKEND_OPS_H
14 
15 #include "hw/xen/xen.h"
16 #include "hw/xen/interface/xen.h"
17 #include "hw/xen/interface/io/xenbus.h"
18 
19 /*
20  * For the time being, these operations map fairly closely to the API of
21  * the actual Xen libraries, e.g. libxenevtchn. As we complete the migration
22  * from XenLegacyDevice back ends to the new XenDevice model, they may
23  * evolve to slightly higher-level APIs.
24  *
25  * The internal emulations do not emulate the Xen APIs entirely faithfully;
26  * only enough to be used by the Xen backend devices. For example, only one
27  * event channel can be bound to each handle, since that's sufficient for
28  * the device support (only the true Xen HVM backend uses more). And the
29  * behaviour of unmask() and pending() is different too because the device
30  * backends don't care.
31  */
32 
33 typedef struct xenevtchn_handle xenevtchn_handle;
34 typedef int xenevtchn_port_or_error_t;
35 typedef uint32_t evtchn_port_t;
36 typedef uint16_t domid_t;
37 typedef uint32_t grant_ref_t;
38 
39 #define XEN_PAGE_SHIFT       12
40 #define XEN_PAGE_SIZE        (1UL << XEN_PAGE_SHIFT)
41 #define XEN_PAGE_MASK        (~(XEN_PAGE_SIZE - 1))
42 
43 #ifndef xen_rmb
44 #define xen_rmb() smp_rmb()
45 #endif
46 #ifndef xen_wmb
47 #define xen_wmb() smp_wmb()
48 #endif
49 #ifndef xen_mb
50 #define xen_mb() smp_mb()
51 #endif
52 
53 struct evtchn_backend_ops {
54     xenevtchn_handle *(*open)(void);
55     int (*bind_interdomain)(xenevtchn_handle *xc, uint32_t domid,
56                             evtchn_port_t guest_port);
57     int (*unbind)(xenevtchn_handle *xc, evtchn_port_t port);
58     int (*close)(struct xenevtchn_handle *xc);
59     int (*get_fd)(struct xenevtchn_handle *xc);
60     int (*notify)(struct xenevtchn_handle *xc, evtchn_port_t port);
61     int (*unmask)(struct xenevtchn_handle *xc, evtchn_port_t port);
62     int (*pending)(struct xenevtchn_handle *xc);
63 };
64 
65 extern struct evtchn_backend_ops *xen_evtchn_ops;
66 
67 static inline xenevtchn_handle *qemu_xen_evtchn_open(void)
68 {
69     if (!xen_evtchn_ops) {
70         return NULL;
71     }
72     return xen_evtchn_ops->open();
73 }
74 
75 static inline int qemu_xen_evtchn_bind_interdomain(xenevtchn_handle *xc,
76                                                    uint32_t domid,
77                                                    evtchn_port_t guest_port)
78 {
79     if (!xen_evtchn_ops) {
80         return -ENOSYS;
81     }
82     return xen_evtchn_ops->bind_interdomain(xc, domid, guest_port);
83 }
84 
85 static inline int qemu_xen_evtchn_unbind(xenevtchn_handle *xc,
86                                          evtchn_port_t port)
87 {
88     if (!xen_evtchn_ops) {
89         return -ENOSYS;
90     }
91     return xen_evtchn_ops->unbind(xc, port);
92 }
93 
94 static inline int qemu_xen_evtchn_close(xenevtchn_handle *xc)
95 {
96     if (!xen_evtchn_ops) {
97         return -ENOSYS;
98     }
99     return xen_evtchn_ops->close(xc);
100 }
101 
102 static inline int qemu_xen_evtchn_fd(xenevtchn_handle *xc)
103 {
104     if (!xen_evtchn_ops) {
105         return -ENOSYS;
106     }
107     return xen_evtchn_ops->get_fd(xc);
108 }
109 
110 static inline int qemu_xen_evtchn_notify(xenevtchn_handle *xc,
111                                          evtchn_port_t port)
112 {
113     if (!xen_evtchn_ops) {
114         return -ENOSYS;
115     }
116     return xen_evtchn_ops->notify(xc, port);
117 }
118 
119 static inline int qemu_xen_evtchn_unmask(xenevtchn_handle *xc,
120                                          evtchn_port_t port)
121 {
122     if (!xen_evtchn_ops) {
123         return -ENOSYS;
124     }
125     return xen_evtchn_ops->unmask(xc, port);
126 }
127 
128 static inline int qemu_xen_evtchn_pending(xenevtchn_handle *xc)
129 {
130     if (!xen_evtchn_ops) {
131         return -ENOSYS;
132     }
133     return xen_evtchn_ops->pending(xc);
134 }
135 
136 typedef struct xengntdev_handle xengnttab_handle;
137 
138 typedef struct XenGrantCopySegment {
139     union {
140         void *virt;
141         struct {
142             uint32_t ref;
143             off_t offset;
144         } foreign;
145     } source, dest;
146     size_t len;
147 } XenGrantCopySegment;
148 
149 #define XEN_GNTTAB_OP_FEATURE_MAP_MULTIPLE  (1U << 0)
150 
151 struct gnttab_backend_ops {
152     uint32_t features;
153     xengnttab_handle *(*open)(void);
154     int (*close)(xengnttab_handle *xgt);
155     int (*grant_copy)(xengnttab_handle *xgt, bool to_domain, uint32_t domid,
156                       XenGrantCopySegment *segs, uint32_t nr_segs,
157                       Error **errp);
158     int (*set_max_grants)(xengnttab_handle *xgt, uint32_t nr_grants);
159     void *(*map_refs)(xengnttab_handle *xgt, uint32_t count, uint32_t domid,
160                       uint32_t *refs, int prot);
161     int (*unmap)(xengnttab_handle *xgt, void *start_address, uint32_t *refs,
162                  uint32_t count);
163 };
164 
165 extern struct gnttab_backend_ops *xen_gnttab_ops;
166 
167 static inline bool qemu_xen_gnttab_can_map_multi(void)
168 {
169     return xen_gnttab_ops &&
170         !!(xen_gnttab_ops->features & XEN_GNTTAB_OP_FEATURE_MAP_MULTIPLE);
171 }
172 
173 static inline xengnttab_handle *qemu_xen_gnttab_open(void)
174 {
175     if (!xen_gnttab_ops) {
176         return NULL;
177     }
178     return xen_gnttab_ops->open();
179 }
180 
181 static inline int qemu_xen_gnttab_close(xengnttab_handle *xgt)
182 {
183     if (!xen_gnttab_ops) {
184         return -ENOSYS;
185     }
186     return xen_gnttab_ops->close(xgt);
187 }
188 
189 static inline int qemu_xen_gnttab_grant_copy(xengnttab_handle *xgt,
190                                              bool to_domain, uint32_t domid,
191                                              XenGrantCopySegment *segs,
192                                              uint32_t nr_segs, Error **errp)
193 {
194     if (!xen_gnttab_ops) {
195         return -ENOSYS;
196     }
197 
198     return xen_gnttab_ops->grant_copy(xgt, to_domain, domid, segs, nr_segs,
199                                       errp);
200 }
201 
202 static inline int qemu_xen_gnttab_set_max_grants(xengnttab_handle *xgt,
203                                                  uint32_t nr_grants)
204 {
205     if (!xen_gnttab_ops) {
206         return -ENOSYS;
207     }
208     return xen_gnttab_ops->set_max_grants(xgt, nr_grants);
209 }
210 
211 static inline void *qemu_xen_gnttab_map_refs(xengnttab_handle *xgt,
212                                              uint32_t count, uint32_t domid,
213                                              uint32_t *refs, int prot)
214 {
215     if (!xen_gnttab_ops) {
216         return NULL;
217     }
218     return xen_gnttab_ops->map_refs(xgt, count, domid, refs, prot);
219 }
220 
221 static inline int qemu_xen_gnttab_unmap(xengnttab_handle *xgt,
222                                         void *start_address, uint32_t *refs,
223                                         uint32_t count)
224 {
225     if (!xen_gnttab_ops) {
226         return -ENOSYS;
227     }
228     return xen_gnttab_ops->unmap(xgt, start_address, refs, count);
229 }
230 
231 struct foreignmem_backend_ops {
232     void *(*map)(uint32_t dom, void *addr, int prot, size_t pages,
233                  xen_pfn_t *pfns, int *errs);
234     int (*unmap)(void *addr, size_t pages);
235 };
236 
237 extern struct foreignmem_backend_ops *xen_foreignmem_ops;
238 
239 static inline void *qemu_xen_foreignmem_map(uint32_t dom, void *addr, int prot,
240                                             size_t pages, xen_pfn_t *pfns,
241                                             int *errs)
242 {
243     if (!xen_foreignmem_ops) {
244         return NULL;
245     }
246     return xen_foreignmem_ops->map(dom, addr, prot, pages, pfns, errs);
247 }
248 
249 static inline int qemu_xen_foreignmem_unmap(void *addr, size_t pages)
250 {
251     if (!xen_foreignmem_ops) {
252         return -ENOSYS;
253     }
254     return xen_foreignmem_ops->unmap(addr, pages);
255 }
256 
257 typedef void (*xs_watch_fn)(void *opaque, const char *path);
258 
259 struct qemu_xs_handle;
260 struct qemu_xs_watch;
261 typedef uint32_t xs_transaction_t;
262 
263 #define XBT_NULL 0
264 
265 #define XS_PERM_NONE  0x00
266 #define XS_PERM_READ  0x01
267 #define XS_PERM_WRITE 0x02
268 
269 struct xenstore_backend_ops {
270     struct qemu_xs_handle *(*open)(void);
271     void (*close)(struct qemu_xs_handle *h);
272     char *(*get_domain_path)(struct qemu_xs_handle *h, unsigned int domid);
273     char **(*directory)(struct qemu_xs_handle *h, xs_transaction_t t,
274                         const char *path, unsigned int *num);
275     void *(*read)(struct qemu_xs_handle *h, xs_transaction_t t,
276                   const char *path, unsigned int *len);
277     bool (*write)(struct qemu_xs_handle *h, xs_transaction_t t,
278                   const char *path, const void *data, unsigned int len);
279     bool (*create)(struct qemu_xs_handle *h, xs_transaction_t t,
280                    unsigned int owner, unsigned int domid,
281                    unsigned int perms, const char *path);
282     bool (*destroy)(struct qemu_xs_handle *h, xs_transaction_t t,
283                const char *path);
284     struct qemu_xs_watch *(*watch)(struct qemu_xs_handle *h, const char *path,
285                                    xs_watch_fn fn, void *opaque);
286     void (*unwatch)(struct qemu_xs_handle *h, struct qemu_xs_watch *w);
287     xs_transaction_t (*transaction_start)(struct qemu_xs_handle *h);
288     bool (*transaction_end)(struct qemu_xs_handle *h, xs_transaction_t t,
289                             bool abort);
290 };
291 
292 extern struct xenstore_backend_ops *xen_xenstore_ops;
293 
294 static inline struct qemu_xs_handle *qemu_xen_xs_open(void)
295 {
296     if (!xen_xenstore_ops) {
297         return NULL;
298     }
299     return xen_xenstore_ops->open();
300 }
301 
302 static inline void qemu_xen_xs_close(struct qemu_xs_handle *h)
303 {
304     if (!xen_xenstore_ops) {
305         return;
306     }
307     xen_xenstore_ops->close(h);
308 }
309 
310 static inline char *qemu_xen_xs_get_domain_path(struct qemu_xs_handle *h,
311                                                 unsigned int domid)
312 {
313     if (!xen_xenstore_ops) {
314         return NULL;
315     }
316     return xen_xenstore_ops->get_domain_path(h, domid);
317 }
318 
319 static inline char **qemu_xen_xs_directory(struct qemu_xs_handle *h,
320                                            xs_transaction_t t, const char *path,
321                                            unsigned int *num)
322 {
323     if (!xen_xenstore_ops) {
324         return NULL;
325     }
326     return xen_xenstore_ops->directory(h, t, path, num);
327 }
328 
329 static inline void *qemu_xen_xs_read(struct qemu_xs_handle *h,
330                                      xs_transaction_t t, const char *path,
331                                      unsigned int *len)
332 {
333     if (!xen_xenstore_ops) {
334         return NULL;
335     }
336     return xen_xenstore_ops->read(h, t, path, len);
337 }
338 
339 static inline bool qemu_xen_xs_write(struct qemu_xs_handle *h,
340                                      xs_transaction_t t, const char *path,
341                                      const void *data, unsigned int len)
342 {
343     if (!xen_xenstore_ops) {
344         return false;
345     }
346     return xen_xenstore_ops->write(h, t, path, data, len);
347 }
348 
349 static inline bool qemu_xen_xs_create(struct qemu_xs_handle *h,
350                                       xs_transaction_t t, unsigned int owner,
351                                       unsigned int domid, unsigned int perms,
352                                       const char *path)
353 {
354     if (!xen_xenstore_ops) {
355         return false;
356     }
357     return xen_xenstore_ops->create(h, t, owner, domid, perms, path);
358 }
359 
360 static inline bool qemu_xen_xs_destroy(struct qemu_xs_handle *h,
361                                        xs_transaction_t t, const char *path)
362 {
363     if (!xen_xenstore_ops) {
364         return false;
365     }
366     return xen_xenstore_ops->destroy(h, t, path);
367 }
368 
369 static inline struct qemu_xs_watch *qemu_xen_xs_watch(struct qemu_xs_handle *h,
370                                                       const char *path,
371                                                       xs_watch_fn fn,
372                                                       void *opaque)
373 {
374     if (!xen_xenstore_ops) {
375         return NULL;
376     }
377     return xen_xenstore_ops->watch(h, path, fn, opaque);
378 }
379 
380 static inline void qemu_xen_xs_unwatch(struct qemu_xs_handle *h,
381                                        struct qemu_xs_watch *w)
382 {
383     if (!xen_xenstore_ops) {
384         return;
385     }
386     xen_xenstore_ops->unwatch(h, w);
387 }
388 
389 static inline xs_transaction_t qemu_xen_xs_transaction_start(struct qemu_xs_handle *h)
390 {
391     if (!xen_xenstore_ops) {
392         return XBT_NULL;
393     }
394     return xen_xenstore_ops->transaction_start(h);
395 }
396 
397 static inline bool qemu_xen_xs_transaction_end(struct qemu_xs_handle *h,
398                                                xs_transaction_t t, bool abort)
399 {
400     if (!xen_xenstore_ops) {
401         return false;
402     }
403     return xen_xenstore_ops->transaction_end(h, t, abort);
404 }
405 
406 void setup_xen_backend_ops(void);
407 
408 #endif /* QEMU_XEN_BACKEND_OPS_H */
409