xref: /freebsd-13.1/sys/xen/interface/memory.h (revision 79e02149)
1 /******************************************************************************
2  * memory.h
3  *
4  * Memory reservation and information.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to
8  * deal in the Software without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22  * DEALINGS IN THE SOFTWARE.
23  *
24  * Copyright (c) 2005, Keir Fraser <[email protected]>
25  */
26 
27 #ifndef __XEN_PUBLIC_MEMORY_H__
28 #define __XEN_PUBLIC_MEMORY_H__
29 
30 #include "xen.h"
31 #include "physdev.h"
32 
33 /*
34  * Increase or decrease the specified domain's memory reservation. Returns the
35  * number of extents successfully allocated or freed.
36  * arg == addr of struct xen_memory_reservation.
37  */
38 #define XENMEM_increase_reservation 0
39 #define XENMEM_decrease_reservation 1
40 #define XENMEM_populate_physmap     6
41 
42 #if __XEN_INTERFACE_VERSION__ >= 0x00030209
43 /*
44  * Maximum # bits addressable by the user of the allocated region (e.g., I/O
45  * devices often have a 32-bit limitation even in 64-bit systems). If zero
46  * then the user has no addressing restriction. This field is not used by
47  * XENMEM_decrease_reservation.
48  */
49 #define XENMEMF_address_bits(x)     (x)
50 #define XENMEMF_get_address_bits(x) ((x) & 0xffu)
51 /* NUMA node to allocate from. */
52 #define XENMEMF_node(x)     (((x) + 1) << 8)
53 #define XENMEMF_get_node(x) ((((x) >> 8) - 1) & 0xffu)
54 /* Flag to populate physmap with populate-on-demand entries */
55 #define XENMEMF_populate_on_demand (1<<16)
56 /* Flag to request allocation only from the node specified */
57 #define XENMEMF_exact_node_request  (1<<17)
58 #define XENMEMF_exact_node(n) (XENMEMF_node(n) | XENMEMF_exact_node_request)
59 /* Flag to indicate the node specified is virtual node */
60 #define XENMEMF_vnode  (1<<18)
61 #endif
62 
63 struct xen_memory_reservation {
64     /*
65      * XENMEM_increase_reservation:
66      *   OUT: MFN (*not* GMFN) bases of extents that were allocated
67      * XENMEM_decrease_reservation:
68      *   IN:  GMFN bases of extents to free
69      * XENMEM_populate_physmap:
70      *   IN:  GPFN bases of extents to populate with memory
71      *   OUT: GMFN bases of extents that were allocated
72      *   (NB. This command also updates the mach_to_phys translation table)
73      * XENMEM_claim_pages:
74      *   IN: must be zero
75      */
76     XEN_GUEST_HANDLE(xen_pfn_t) extent_start;
77 
78     /* Number of extents, and size/alignment of each (2^extent_order pages). */
79     xen_ulong_t    nr_extents;
80     unsigned int   extent_order;
81 
82 #if __XEN_INTERFACE_VERSION__ >= 0x00030209
83     /* XENMEMF flags. */
84     unsigned int   mem_flags;
85 #else
86     unsigned int   address_bits;
87 #endif
88 
89     /*
90      * Domain whose reservation is being changed.
91      * Unprivileged domains can specify only DOMID_SELF.
92      */
93     domid_t        domid;
94 };
95 typedef struct xen_memory_reservation xen_memory_reservation_t;
96 DEFINE_XEN_GUEST_HANDLE(xen_memory_reservation_t);
97 
98 /*
99  * An atomic exchange of memory pages. If return code is zero then
100  * @out.extent_list provides GMFNs of the newly-allocated memory.
101  * Returns zero on complete success, otherwise a negative error code.
102  * On complete success then always @nr_exchanged == @in.nr_extents.
103  * On partial success @nr_exchanged indicates how much work was done.
104  */
105 #define XENMEM_exchange             11
106 struct xen_memory_exchange {
107     /*
108      * [IN] Details of memory extents to be exchanged (GMFN bases).
109      * Note that @in.address_bits is ignored and unused.
110      */
111     struct xen_memory_reservation in;
112 
113     /*
114      * [IN/OUT] Details of new memory extents.
115      * We require that:
116      *  1. @in.domid == @out.domid
117      *  2. @in.nr_extents  << @in.extent_order ==
118      *     @out.nr_extents << @out.extent_order
119      *  3. @in.extent_start and @out.extent_start lists must not overlap
120      *  4. @out.extent_start lists GPFN bases to be populated
121      *  5. @out.extent_start is overwritten with allocated GMFN bases
122      */
123     struct xen_memory_reservation out;
124 
125     /*
126      * [OUT] Number of input extents that were successfully exchanged:
127      *  1. The first @nr_exchanged input extents were successfully
128      *     deallocated.
129      *  2. The corresponding first entries in the output extent list correctly
130      *     indicate the GMFNs that were successfully exchanged.
131      *  3. All other input and output extents are untouched.
132      *  4. If not all input exents are exchanged then the return code of this
133      *     command will be non-zero.
134      *  5. THIS FIELD MUST BE INITIALISED TO ZERO BY THE CALLER!
135      */
136     xen_ulong_t nr_exchanged;
137 };
138 typedef struct xen_memory_exchange xen_memory_exchange_t;
139 DEFINE_XEN_GUEST_HANDLE(xen_memory_exchange_t);
140 
141 /*
142  * Returns the maximum machine frame number of mapped RAM in this system.
143  * This command always succeeds (it never returns an error code).
144  * arg == NULL.
145  */
146 #define XENMEM_maximum_ram_page     2
147 
148 /*
149  * Returns the current or maximum memory reservation, in pages, of the
150  * specified domain (may be DOMID_SELF). Returns -ve errcode on failure.
151  * arg == addr of domid_t.
152  */
153 #define XENMEM_current_reservation  3
154 #define XENMEM_maximum_reservation  4
155 
156 /*
157  * Returns the maximum GPFN in use by the guest, or -ve errcode on failure.
158  */
159 #define XENMEM_maximum_gpfn         14
160 
161 /*
162  * Returns a list of MFN bases of 2MB extents comprising the machine_to_phys
163  * mapping table. Architectures which do not have a m2p table do not implement
164  * this command.
165  * arg == addr of xen_machphys_mfn_list_t.
166  */
167 #define XENMEM_machphys_mfn_list    5
168 struct xen_machphys_mfn_list {
169     /*
170      * Size of the 'extent_start' array. Fewer entries will be filled if the
171      * machphys table is smaller than max_extents * 2MB.
172      */
173     unsigned int max_extents;
174 
175     /*
176      * Pointer to buffer to fill with list of extent starts. If there are
177      * any large discontiguities in the machine address space, 2MB gaps in
178      * the machphys table will be represented by an MFN base of zero.
179      */
180     XEN_GUEST_HANDLE(xen_pfn_t) extent_start;
181 
182     /*
183      * Number of extents written to the above array. This will be smaller
184      * than 'max_extents' if the machphys table is smaller than max_e * 2MB.
185      */
186     unsigned int nr_extents;
187 };
188 typedef struct xen_machphys_mfn_list xen_machphys_mfn_list_t;
189 DEFINE_XEN_GUEST_HANDLE(xen_machphys_mfn_list_t);
190 
191 /*
192  * For a compat caller, this is identical to XENMEM_machphys_mfn_list.
193  *
194  * For a non compat caller, this functions similarly to
195  * XENMEM_machphys_mfn_list, but returns the mfns making up the compatibility
196  * m2p table.
197  */
198 #define XENMEM_machphys_compat_mfn_list     25
199 
200 /*
201  * Returns the location in virtual address space of the machine_to_phys
202  * mapping table. Architectures which do not have a m2p table, or which do not
203  * map it by default into guest address space, do not implement this command.
204  * arg == addr of xen_machphys_mapping_t.
205  */
206 #define XENMEM_machphys_mapping     12
207 struct xen_machphys_mapping {
208     xen_ulong_t v_start, v_end; /* Start and end virtual addresses.   */
209     xen_ulong_t max_mfn;        /* Maximum MFN that can be looked up. */
210 };
211 typedef struct xen_machphys_mapping xen_machphys_mapping_t;
212 DEFINE_XEN_GUEST_HANDLE(xen_machphys_mapping_t);
213 
214 /* Source mapping space. */
215 /* ` enum phys_map_space { */
216 #define XENMAPSPACE_shared_info  0 /* shared info page */
217 #define XENMAPSPACE_grant_table  1 /* grant table page */
218 #define XENMAPSPACE_gmfn         2 /* GMFN */
219 #define XENMAPSPACE_gmfn_range   3 /* GMFN range, XENMEM_add_to_physmap only. */
220 #define XENMAPSPACE_gmfn_foreign 4 /* GMFN from another dom,
221                                     * XENMEM_add_to_physmap_batch only. */
222 /* ` } */
223 
224 /*
225  * Sets the GPFN at which a particular page appears in the specified guest's
226  * pseudophysical address space.
227  * arg == addr of xen_add_to_physmap_t.
228  */
229 #define XENMEM_add_to_physmap      7
230 struct xen_add_to_physmap {
231     /* Which domain to change the mapping for. */
232     domid_t domid;
233 
234     /* Number of pages to go through for gmfn_range */
235     uint16_t    size;
236 
237     unsigned int space; /* => enum phys_map_space */
238 
239 #define XENMAPIDX_grant_table_status 0x80000000
240 
241     /* Index into space being mapped. */
242     xen_ulong_t idx;
243 
244     /* GPFN in domid where the source mapping page should appear. */
245     xen_pfn_t     gpfn;
246 };
247 typedef struct xen_add_to_physmap xen_add_to_physmap_t;
248 DEFINE_XEN_GUEST_HANDLE(xen_add_to_physmap_t);
249 
250 /* A batched version of add_to_physmap. */
251 #define XENMEM_add_to_physmap_batch 23
252 struct xen_add_to_physmap_batch {
253     /* IN */
254     /* Which domain to change the mapping for. */
255     domid_t domid;
256     uint16_t space; /* => enum phys_map_space */
257 
258     /* Number of pages to go through */
259     uint16_t size;
260     domid_t foreign_domid; /* IFF gmfn_foreign */
261 
262     /* Indexes into space being mapped. */
263     XEN_GUEST_HANDLE(xen_ulong_t) idxs;
264 
265     /* GPFN in domid where the source mapping page should appear. */
266     XEN_GUEST_HANDLE(xen_pfn_t) gpfns;
267 
268     /* OUT */
269 
270     /* Per index error code. */
271     XEN_GUEST_HANDLE(int) errs;
272 };
273 typedef struct xen_add_to_physmap_batch xen_add_to_physmap_batch_t;
274 DEFINE_XEN_GUEST_HANDLE(xen_add_to_physmap_batch_t);
275 
276 #if __XEN_INTERFACE_VERSION__ < 0x00040400
277 #define XENMEM_add_to_physmap_range XENMEM_add_to_physmap_batch
278 #define xen_add_to_physmap_range xen_add_to_physmap_batch
279 typedef struct xen_add_to_physmap_batch xen_add_to_physmap_range_t;
280 DEFINE_XEN_GUEST_HANDLE(xen_add_to_physmap_range_t);
281 #endif
282 
283 /*
284  * Unmaps the page appearing at a particular GPFN from the specified guest's
285  * pseudophysical address space.
286  * arg == addr of xen_remove_from_physmap_t.
287  */
288 #define XENMEM_remove_from_physmap      15
289 struct xen_remove_from_physmap {
290     /* Which domain to change the mapping for. */
291     domid_t domid;
292 
293     /* GPFN of the current mapping of the page. */
294     xen_pfn_t     gpfn;
295 };
296 typedef struct xen_remove_from_physmap xen_remove_from_physmap_t;
297 DEFINE_XEN_GUEST_HANDLE(xen_remove_from_physmap_t);
298 
299 /*** REMOVED ***/
300 /*#define XENMEM_translate_gpfn_list  8*/
301 
302 /*
303  * Returns the pseudo-physical memory map as it was when the domain
304  * was started (specified by XENMEM_set_memory_map).
305  * arg == addr of xen_memory_map_t.
306  */
307 #define XENMEM_memory_map           9
308 struct xen_memory_map {
309     /*
310      * On call the number of entries which can be stored in buffer. On
311      * return the number of entries which have been stored in
312      * buffer.
313      */
314     unsigned int nr_entries;
315 
316     /*
317      * Entries in the buffer are in the same format as returned by the
318      * BIOS INT 0x15 EAX=0xE820 call.
319      */
320     XEN_GUEST_HANDLE(void) buffer;
321 };
322 typedef struct xen_memory_map xen_memory_map_t;
323 DEFINE_XEN_GUEST_HANDLE(xen_memory_map_t);
324 
325 /*
326  * Returns the real physical memory map. Passes the same structure as
327  * XENMEM_memory_map.
328  * arg == addr of xen_memory_map_t.
329  */
330 #define XENMEM_machine_memory_map   10
331 
332 /*
333  * Set the pseudo-physical memory map of a domain, as returned by
334  * XENMEM_memory_map.
335  * arg == addr of xen_foreign_memory_map_t.
336  */
337 #define XENMEM_set_memory_map       13
338 struct xen_foreign_memory_map {
339     domid_t domid;
340     struct xen_memory_map map;
341 };
342 typedef struct xen_foreign_memory_map xen_foreign_memory_map_t;
343 DEFINE_XEN_GUEST_HANDLE(xen_foreign_memory_map_t);
344 
345 #define XENMEM_set_pod_target       16
346 #define XENMEM_get_pod_target       17
347 struct xen_pod_target {
348     /* IN */
349     uint64_t target_pages;
350     /* OUT */
351     uint64_t tot_pages;
352     uint64_t pod_cache_pages;
353     uint64_t pod_entries;
354     /* IN */
355     domid_t domid;
356 };
357 typedef struct xen_pod_target xen_pod_target_t;
358 
359 #if defined(__XEN__) || defined(__XEN_TOOLS__)
360 
361 #ifndef uint64_aligned_t
362 #define uint64_aligned_t uint64_t
363 #endif
364 
365 /*
366  * Get the number of MFNs saved through memory sharing.
367  * The call never fails.
368  */
369 #define XENMEM_get_sharing_freed_pages    18
370 #define XENMEM_get_sharing_shared_pages   19
371 
372 #define XENMEM_paging_op                    20
373 #define XENMEM_paging_op_nominate           0
374 #define XENMEM_paging_op_evict              1
375 #define XENMEM_paging_op_prep               2
376 
377 struct xen_mem_paging_op {
378     uint8_t     op;         /* XENMEM_paging_op_* */
379     domid_t     domain;
380 
381     /* PAGING_PREP IN: buffer to immediately fill page in */
382     uint64_aligned_t    buffer;
383     /* Other OPs */
384     uint64_aligned_t    gfn;           /* IN:  gfn of page being operated on */
385 };
386 typedef struct xen_mem_paging_op xen_mem_paging_op_t;
387 DEFINE_XEN_GUEST_HANDLE(xen_mem_paging_op_t);
388 
389 #define XENMEM_access_op                    21
390 #define XENMEM_access_op_set_access         0
391 #define XENMEM_access_op_get_access         1
392 #define XENMEM_access_op_enable_emulate     2
393 #define XENMEM_access_op_disable_emulate    3
394 
395 typedef enum {
396     XENMEM_access_n,
397     XENMEM_access_r,
398     XENMEM_access_w,
399     XENMEM_access_rw,
400     XENMEM_access_x,
401     XENMEM_access_rx,
402     XENMEM_access_wx,
403     XENMEM_access_rwx,
404     /*
405      * Page starts off as r-x, but automatically
406      * change to r-w on a write
407      */
408     XENMEM_access_rx2rw,
409     /*
410      * Log access: starts off as n, automatically
411      * goes to rwx, generating an event without
412      * pausing the vcpu
413      */
414     XENMEM_access_n2rwx,
415     /* Take the domain default */
416     XENMEM_access_default
417 } xenmem_access_t;
418 
419 struct xen_mem_access_op {
420     /* XENMEM_access_op_* */
421     uint8_t op;
422     /* xenmem_access_t */
423     uint8_t access;
424     domid_t domid;
425     /*
426      * Number of pages for set op
427      * Ignored on setting default access and other ops
428      */
429     uint32_t nr;
430     /*
431      * First pfn for set op
432      * pfn for get op
433      * ~0ull is used to set and get the default access for pages
434      */
435     uint64_aligned_t pfn;
436 };
437 typedef struct xen_mem_access_op xen_mem_access_op_t;
438 DEFINE_XEN_GUEST_HANDLE(xen_mem_access_op_t);
439 
440 #define XENMEM_sharing_op                   22
441 #define XENMEM_sharing_op_nominate_gfn      0
442 #define XENMEM_sharing_op_nominate_gref     1
443 #define XENMEM_sharing_op_share             2
444 #define XENMEM_sharing_op_debug_gfn         3
445 #define XENMEM_sharing_op_debug_mfn         4
446 #define XENMEM_sharing_op_debug_gref        5
447 #define XENMEM_sharing_op_add_physmap       6
448 #define XENMEM_sharing_op_audit             7
449 
450 #define XENMEM_SHARING_OP_S_HANDLE_INVALID  (-10)
451 #define XENMEM_SHARING_OP_C_HANDLE_INVALID  (-9)
452 
453 /* The following allows sharing of grant refs. This is useful
454  * for sharing utilities sitting as "filters" in IO backends
455  * (e.g. memshr + blktap(2)). The IO backend is only exposed
456  * to grant references, and this allows sharing of the grefs */
457 #define XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG   (1ULL << 62)
458 
459 #define XENMEM_SHARING_OP_FIELD_MAKE_GREF(field, val)  \
460     (field) = (XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG | val)
461 #define XENMEM_SHARING_OP_FIELD_IS_GREF(field)         \
462     ((field) & XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG)
463 #define XENMEM_SHARING_OP_FIELD_GET_GREF(field)        \
464     ((field) & (~XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG))
465 
466 struct xen_mem_sharing_op {
467     uint8_t     op;     /* XENMEM_sharing_op_* */
468     domid_t     domain;
469 
470     union {
471         struct mem_sharing_op_nominate {  /* OP_NOMINATE_xxx           */
472             union {
473                 uint64_aligned_t gfn;     /* IN: gfn to nominate       */
474                 uint32_t      grant_ref;  /* IN: grant ref to nominate */
475             } u;
476             uint64_aligned_t  handle;     /* OUT: the handle           */
477         } nominate;
478         struct mem_sharing_op_share {     /* OP_SHARE/ADD_PHYSMAP */
479             uint64_aligned_t source_gfn;    /* IN: the gfn of the source page */
480             uint64_aligned_t source_handle; /* IN: handle to the source page */
481             uint64_aligned_t client_gfn;    /* IN: the client gfn */
482             uint64_aligned_t client_handle; /* IN: handle to the client page */
483             domid_t  client_domain; /* IN: the client domain id */
484         } share;
485         struct mem_sharing_op_debug {     /* OP_DEBUG_xxx */
486             union {
487                 uint64_aligned_t gfn;      /* IN: gfn to debug          */
488                 uint64_aligned_t mfn;      /* IN: mfn to debug          */
489                 uint32_t gref;     /* IN: gref to debug         */
490             } u;
491         } debug;
492     } u;
493 };
494 typedef struct xen_mem_sharing_op xen_mem_sharing_op_t;
495 DEFINE_XEN_GUEST_HANDLE(xen_mem_sharing_op_t);
496 
497 /*
498  * Attempt to stake a claim for a domain on a quantity of pages
499  * of system RAM, but _not_ assign specific pageframes.  Only
500  * arithmetic is performed so the hypercall is very fast and need
501  * not be preemptible, thus sidestepping time-of-check-time-of-use
502  * races for memory allocation.  Returns 0 if the hypervisor page
503  * allocator has atomically and successfully claimed the requested
504  * number of pages, else non-zero.
505  *
506  * Any domain may have only one active claim.  When sufficient memory
507  * has been allocated to resolve the claim, the claim silently expires.
508  * Claiming zero pages effectively resets any outstanding claim and
509  * is always successful.
510  *
511  * Note that a valid claim may be staked even after memory has been
512  * allocated for a domain.  In this case, the claim is not incremental,
513  * i.e. if the domain's tot_pages is 3, and a claim is staked for 10,
514  * only 7 additional pages are claimed.
515  *
516  * Caller must be privileged or the hypercall fails.
517  */
518 #define XENMEM_claim_pages                  24
519 
520 /*
521  * XENMEM_claim_pages flags - the are no flags at this time.
522  * The zero value is appropiate.
523  */
524 
525 /*
526  * With some legacy devices, certain guest-physical addresses cannot safely
527  * be used for other purposes, e.g. to map guest RAM.  This hypercall
528  * enumerates those regions so the toolstack can avoid using them.
529  */
530 #define XENMEM_reserved_device_memory_map   27
531 struct xen_reserved_device_memory {
532     xen_pfn_t start_pfn;
533     xen_ulong_t nr_pages;
534 };
535 typedef struct xen_reserved_device_memory xen_reserved_device_memory_t;
536 DEFINE_XEN_GUEST_HANDLE(xen_reserved_device_memory_t);
537 
538 struct xen_reserved_device_memory_map {
539 #define XENMEM_RDM_ALL 1 /* Request all regions (ignore dev union). */
540     /* IN */
541     uint32_t flags;
542     /*
543      * IN/OUT
544      *
545      * Gets set to the required number of entries when too low,
546      * signaled by error code -ERANGE.
547      */
548     unsigned int nr_entries;
549     /* OUT */
550     XEN_GUEST_HANDLE(xen_reserved_device_memory_t) buffer;
551     /* IN */
552     union {
553         struct physdev_pci_device pci;
554     } dev;
555 };
556 typedef struct xen_reserved_device_memory_map xen_reserved_device_memory_map_t;
557 DEFINE_XEN_GUEST_HANDLE(xen_reserved_device_memory_map_t);
558 
559 #endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */
560 
561 /*
562  * XENMEM_get_vnumainfo used by guest to get
563  * vNUMA topology from hypervisor.
564  */
565 #define XENMEM_get_vnumainfo                26
566 
567 /* vNUMA node memory ranges */
568 struct xen_vmemrange {
569     uint64_t start, end;
570     unsigned int flags;
571     unsigned int nid;
572 };
573 typedef struct xen_vmemrange xen_vmemrange_t;
574 DEFINE_XEN_GUEST_HANDLE(xen_vmemrange_t);
575 
576 /*
577  * vNUMA topology specifies vNUMA node number, distance table,
578  * memory ranges and vcpu mapping provided for guests.
579  * XENMEM_get_vnumainfo hypercall expects to see from guest
580  * nr_vnodes, nr_vmemranges and nr_vcpus to indicate available memory.
581  * After filling guests structures, nr_vnodes, nr_vmemranges and nr_vcpus
582  * copied back to guest. Domain returns expected values of nr_vnodes,
583  * nr_vmemranges and nr_vcpus to guest if the values where incorrect.
584  */
585 struct xen_vnuma_topology_info {
586     /* IN */
587     domid_t domid;
588     uint16_t pad;
589     /* IN/OUT */
590     unsigned int nr_vnodes;
591     unsigned int nr_vcpus;
592     unsigned int nr_vmemranges;
593     /* OUT */
594     union {
595         XEN_GUEST_HANDLE(uint) h;
596         uint64_t pad;
597     } vdistance;
598     union {
599         XEN_GUEST_HANDLE(uint) h;
600         uint64_t pad;
601     } vcpu_to_vnode;
602     union {
603         XEN_GUEST_HANDLE(xen_vmemrange_t) h;
604         uint64_t pad;
605     } vmemrange;
606 };
607 typedef struct xen_vnuma_topology_info xen_vnuma_topology_info_t;
608 DEFINE_XEN_GUEST_HANDLE(xen_vnuma_topology_info_t);
609 
610 /* Next available subop number is 28 */
611 
612 #endif /* __XEN_PUBLIC_MEMORY_H__ */
613 
614 /*
615  * Local variables:
616  * mode: C
617  * c-file-style: "BSD"
618  * c-basic-offset: 4
619  * tab-width: 4
620  * indent-tabs-mode: nil
621  * End:
622  */
623