ia64/xen-unstable

view tools/libxc/xenctrl.h @ 15854:9071521d4864

xc_map_foreign_pages(), a convenient alternative to xc_map_foreign_batch()

xc_map_foreign_batch() can succeed partially. It is awkward to use
when you're only interested in complete success. Provide new
xc_map_foreign_pages() convenience function for that kind of use.
Also convert two obvious calls to use it.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
author kfraser@localhost.localdomain
date Fri Sep 07 11:39:10 2007 +0100 (2007-09-07)
parents 7e7e0ea6a0bb
children f16bff0934d7
line source
1 /******************************************************************************
2 * xenctrl.h
3 *
4 * A library for low-level access to the Xen control interfaces.
5 *
6 * Copyright (c) 2003-2004, K A Fraser.
7 *
8 * xc_gnttab functions:
9 * Copyright (c) 2007, D G Murray <Derek.Murray@cl.cam.ac.uk>
10 */
12 #ifndef XENCTRL_H
13 #define XENCTRL_H
15 /* Tell the Xen public headers we are a user-space tools build. */
16 #ifndef __XEN_TOOLS__
17 #define __XEN_TOOLS__ 1
18 #endif
20 #include <stddef.h>
21 #include <stdint.h>
22 #include <xen/xen.h>
23 #include <xen/domctl.h>
24 #include <xen/sysctl.h>
25 #include <xen/version.h>
26 #include <xen/event_channel.h>
27 #include <xen/sched.h>
28 #include <xen/memory.h>
29 #include <xen/xsm/acm.h>
30 #include <xen/xsm/acm_ops.h>
32 #ifdef __ia64__
33 #define XC_PAGE_SHIFT 14
34 #else
35 #define XC_PAGE_SHIFT 12
36 #endif
37 #define XC_PAGE_SIZE (1UL << XC_PAGE_SHIFT)
38 #define XC_PAGE_MASK (~(XC_PAGE_SIZE-1))
40 /*
41 * DEFINITIONS FOR CPU BARRIERS
42 */
44 #if defined(__i386__)
45 #define mb() __asm__ __volatile__ ( "lock; addl $0,0(%%esp)" : : : "memory" )
46 #define rmb() __asm__ __volatile__ ( "lock; addl $0,0(%%esp)" : : : "memory" )
47 #define wmb() __asm__ __volatile__ ( "" : : : "memory")
48 #elif defined(__x86_64__)
49 #define mb() __asm__ __volatile__ ( "mfence" : : : "memory")
50 #define rmb() __asm__ __volatile__ ( "lfence" : : : "memory")
51 #define wmb() __asm__ __volatile__ ( "" : : : "memory")
52 #elif defined(__ia64__)
53 #define mb() __asm__ __volatile__ ("mf" ::: "memory")
54 #define rmb() __asm__ __volatile__ ("mf" ::: "memory")
55 #define wmb() __asm__ __volatile__ ("mf" ::: "memory")
56 #elif defined(__powerpc__)
57 /* XXX loosen these up later */
58 #define mb() __asm__ __volatile__ ("sync" : : : "memory")
59 #define rmb() __asm__ __volatile__ ("sync" : : : "memory") /* lwsync? */
60 #define wmb() __asm__ __volatile__ ("sync" : : : "memory") /* eieio? */
61 #else
62 #error "Define barriers"
63 #endif
65 /*
66 * INITIALIZATION FUNCTIONS
67 */
69 /**
70 * This function opens a handle to the hypervisor interface. This function can
71 * be called multiple times within a single process. Multiple processes can
72 * have an open hypervisor interface at the same time.
73 *
74 * Each call to this function should have a corresponding call to
75 * xc_interface_close().
76 *
77 * This function can fail if the caller does not have superuser permission or
78 * if a Xen-enabled kernel is not currently running.
79 *
80 * @return a handle to the hypervisor interface or -1 on failure
81 */
82 int xc_interface_open(void);
84 /**
85 * This function closes an open hypervisor interface.
86 *
87 * This function can fail if the handle does not represent an open interface or
88 * if there were problems closing the interface.
89 *
90 * @parm xc_handle a handle to an open hypervisor interface
91 * @return 0 on success, -1 otherwise.
92 */
93 int xc_interface_close(int xc_handle);
95 /*
96 * KERNEL INTERFACES
97 */
99 /*
100 * Resolve a kernel device name (e.g., "evtchn", "blktap0") into a kernel
101 * device number. Returns -1 on error (and sets errno).
102 */
103 int xc_find_device_number(const char *name);
105 /*
106 * DOMAIN DEBUGGING FUNCTIONS
107 */
109 typedef struct xc_core_header {
110 unsigned int xch_magic;
111 unsigned int xch_nr_vcpus;
112 unsigned int xch_nr_pages;
113 unsigned int xch_ctxt_offset;
114 unsigned int xch_index_offset;
115 unsigned int xch_pages_offset;
116 } xc_core_header_t;
118 #define XC_CORE_MAGIC 0xF00FEBED
119 #define XC_CORE_MAGIC_HVM 0xF00FEBEE
121 #ifdef __linux__
123 #include <sys/ptrace.h>
124 #include <thread_db.h>
126 typedef void (*thr_ev_handler_t)(long);
128 void xc_register_event_handler(
129 thr_ev_handler_t h,
130 td_event_e e);
132 long xc_ptrace(
133 int xc_handle,
134 enum __ptrace_request request,
135 uint32_t domid,
136 long addr,
137 long data);
139 int xc_waitdomain(
140 int xc_handle,
141 int domain,
142 int *status,
143 int options);
145 #endif /* __linux__ */
147 /*
148 * DOMAIN MANAGEMENT FUNCTIONS
149 */
151 typedef struct xc_dominfo {
152 uint32_t domid;
153 uint32_t ssidref;
154 unsigned int dying:1, crashed:1, shutdown:1,
155 paused:1, blocked:1, running:1,
156 hvm:1, debugged:1;
157 unsigned int shutdown_reason; /* only meaningful if shutdown==1 */
158 unsigned long nr_pages;
159 unsigned long shared_info_frame;
160 uint64_t cpu_time;
161 unsigned long max_memkb;
162 unsigned int nr_online_vcpus;
163 unsigned int max_vcpu_id;
164 xen_domain_handle_t handle;
165 } xc_dominfo_t;
167 typedef xen_domctl_getdomaininfo_t xc_domaininfo_t;
168 int xc_domain_create(int xc_handle,
169 uint32_t ssidref,
170 xen_domain_handle_t handle,
171 uint32_t flags,
172 uint32_t *pdomid);
175 /* Functions to produce a dump of a given domain
176 * xc_domain_dumpcore - produces a dump to a specified file
177 * xc_domain_dumpcore_via_callback - produces a dump, using a specified
178 * callback function
179 */
180 int xc_domain_dumpcore(int xc_handle,
181 uint32_t domid,
182 const char *corename);
184 /* Define the callback function type for xc_domain_dumpcore_via_callback.
185 *
186 * This function is called by the coredump code for every "write",
187 * and passes an opaque object for the use of the function and
188 * created by the caller of xc_domain_dumpcore_via_callback.
189 */
190 typedef int (dumpcore_rtn_t)(void *arg, char *buffer, unsigned int length);
192 int xc_domain_dumpcore_via_callback(int xc_handle,
193 uint32_t domid,
194 void *arg,
195 dumpcore_rtn_t dump_rtn);
197 /*
198 * This function sets the maximum number of vcpus that a domain may create.
199 *
200 * @parm xc_handle a handle to an open hypervisor interface.
201 * @parm domid the domain id in which vcpus are to be created.
202 * @parm max the maximum number of vcpus that the domain may create.
203 * @return 0 on success, -1 on failure.
204 */
205 int xc_domain_max_vcpus(int xc_handle,
206 uint32_t domid,
207 unsigned int max);
209 /**
210 * This function pauses a domain. A paused domain still exists in memory
211 * however it does not receive any timeslices from the hypervisor.
212 *
213 * @parm xc_handle a handle to an open hypervisor interface
214 * @parm domid the domain id to pause
215 * @return 0 on success, -1 on failure.
216 */
217 int xc_domain_pause(int xc_handle,
218 uint32_t domid);
219 /**
220 * This function unpauses a domain. The domain should have been previously
221 * paused.
222 *
223 * @parm xc_handle a handle to an open hypervisor interface
224 * @parm domid the domain id to unpause
225 * return 0 on success, -1 on failure
226 */
227 int xc_domain_unpause(int xc_handle,
228 uint32_t domid);
230 /**
231 * This function will destroy a domain. Destroying a domain removes the domain
232 * completely from memory. This function should be called after sending the
233 * domain a SHUTDOWN control message to free up the domain resources.
234 *
235 * @parm xc_handle a handle to an open hypervisor interface
236 * @parm domid the domain id to destroy
237 * @return 0 on success, -1 on failure
238 */
239 int xc_domain_destroy(int xc_handle,
240 uint32_t domid);
243 /**
244 * This function resumes a suspended domain. The domain should have
245 * been previously suspended.
246 *
247 * @parm xc_handle a handle to an open hypervisor interface
248 * @parm domid the domain id to resume
249 * @parm fast use cooperative resume (guest must support this)
250 * return 0 on success, -1 on failure
251 */
252 int xc_domain_resume(int xc_handle,
253 uint32_t domid,
254 int fast);
256 /**
257 * This function will shutdown a domain. This is intended for use in
258 * fully-virtualized domains where this operation is analogous to the
259 * sched_op operations in a paravirtualized domain. The caller is
260 * expected to give the reason for the shutdown.
261 *
262 * @parm xc_handle a handle to an open hypervisor interface
263 * @parm domid the domain id to destroy
264 * @parm reason is the reason (SHUTDOWN_xxx) for the shutdown
265 * @return 0 on success, -1 on failure
266 */
267 int xc_domain_shutdown(int xc_handle,
268 uint32_t domid,
269 int reason);
271 int xc_vcpu_setaffinity(int xc_handle,
272 uint32_t domid,
273 int vcpu,
274 uint64_t cpumap);
275 int xc_vcpu_getaffinity(int xc_handle,
276 uint32_t domid,
277 int vcpu,
278 uint64_t *cpumap);
280 /**
281 * This function will return information about one or more domains. It is
282 * designed to iterate over the list of domains. If a single domain is
283 * requested, this function will return the next domain in the list - if
284 * one exists. It is, therefore, important in this case to make sure the
285 * domain requested was the one returned.
286 *
287 * @parm xc_handle a handle to an open hypervisor interface
288 * @parm first_domid the first domain to enumerate information from. Domains
289 * are currently enumerate in order of creation.
290 * @parm max_doms the number of elements in info
291 * @parm info an array of max_doms size that will contain the information for
292 * the enumerated domains.
293 * @return the number of domains enumerated or -1 on error
294 */
295 int xc_domain_getinfo(int xc_handle,
296 uint32_t first_domid,
297 unsigned int max_doms,
298 xc_dominfo_t *info);
301 /**
302 * This function will set the execution context for the specified vcpu.
303 *
304 * @parm xc_handle a handle to an open hypervisor interface
305 * @parm domid the domain to set the vcpu context for
306 * @parm vcpu the vcpu number for the context
307 * @parm ctxt pointer to the the cpu context with the values to set
308 * @return the number of domains enumerated or -1 on error
309 */
310 int xc_vcpu_setcontext(int xc_handle,
311 uint32_t domid,
312 uint32_t vcpu,
313 vcpu_guest_context_t *ctxt);
314 /**
315 * This function will return information about one or more domains, using a
316 * single hypercall. The domain information will be stored into the supplied
317 * array of xc_domaininfo_t structures.
318 *
319 * @parm xc_handle a handle to an open hypervisor interface
320 * @parm first_domain the first domain to enumerate information from.
321 * Domains are currently enumerate in order of creation.
322 * @parm max_domains the number of elements in info
323 * @parm info an array of max_doms size that will contain the information for
324 * the enumerated domains.
325 * @return the number of domains enumerated or -1 on error
326 */
327 int xc_domain_getinfolist(int xc_handle,
328 uint32_t first_domain,
329 unsigned int max_domains,
330 xc_domaininfo_t *info);
332 /**
333 * This function returns information about the context of a hvm domain
334 * @parm xc_handle a handle to an open hypervisor interface
335 * @parm domid the domain to get information from
336 * @parm ctxt_buf a pointer to a structure to store the execution context of
337 * the hvm domain
338 * @parm size the size of ctxt_buf in bytes
339 * @return 0 on success, -1 on failure
340 */
341 int xc_domain_hvm_getcontext(int xc_handle,
342 uint32_t domid,
343 uint8_t *ctxt_buf,
344 uint32_t size);
346 /**
347 * This function will set the context for hvm domain
348 *
349 * @parm xc_handle a handle to an open hypervisor interface
350 * @parm domid the domain to set the hvm domain context for
351 * @parm hvm_ctxt pointer to the the hvm context with the values to set
352 * @parm size the size of hvm_ctxt in bytes
353 * @return 0 on success, -1 on failure
354 */
355 int xc_domain_hvm_setcontext(int xc_handle,
356 uint32_t domid,
357 uint8_t *hvm_ctxt,
358 uint32_t size);
360 /**
361 * This function returns information about the execution context of a
362 * particular vcpu of a domain.
363 *
364 * @parm xc_handle a handle to an open hypervisor interface
365 * @parm domid the domain to get information from
366 * @parm vcpu the vcpu number
367 * @parm ctxt a pointer to a structure to store the execution context of the
368 * domain
369 * @return 0 on success, -1 on failure
370 */
371 int xc_vcpu_getcontext(int xc_handle,
372 uint32_t domid,
373 uint32_t vcpu,
374 vcpu_guest_context_t *ctxt);
376 typedef xen_domctl_getvcpuinfo_t xc_vcpuinfo_t;
377 int xc_vcpu_getinfo(int xc_handle,
378 uint32_t domid,
379 uint32_t vcpu,
380 xc_vcpuinfo_t *info);
382 int xc_domain_setcpuweight(int xc_handle,
383 uint32_t domid,
384 float weight);
385 long long xc_domain_get_cpu_usage(int xc_handle,
386 domid_t domid,
387 int vcpu);
389 int xc_domain_sethandle(int xc_handle, uint32_t domid,
390 xen_domain_handle_t handle);
392 typedef xen_domctl_shadow_op_stats_t xc_shadow_op_stats_t;
393 int xc_shadow_control(int xc_handle,
394 uint32_t domid,
395 unsigned int sop,
396 unsigned long *dirty_bitmap,
397 unsigned long pages,
398 unsigned long *mb,
399 uint32_t mode,
400 xc_shadow_op_stats_t *stats);
402 int xc_sedf_domain_set(int xc_handle,
403 uint32_t domid,
404 uint64_t period, uint64_t slice,
405 uint64_t latency, uint16_t extratime,
406 uint16_t weight);
408 int xc_sedf_domain_get(int xc_handle,
409 uint32_t domid,
410 uint64_t* period, uint64_t *slice,
411 uint64_t *latency, uint16_t *extratime,
412 uint16_t *weight);
414 int xc_sched_credit_domain_set(int xc_handle,
415 uint32_t domid,
416 struct xen_domctl_sched_credit *sdom);
418 int xc_sched_credit_domain_get(int xc_handle,
419 uint32_t domid,
420 struct xen_domctl_sched_credit *sdom);
422 /**
423 * This function sends a trigger to a domain.
424 *
425 * @parm xc_handle a handle to an open hypervisor interface
426 * @parm domid the domain id to send trigger
427 * @parm trigger the trigger type
428 * @parm vcpu the vcpu number to send trigger
429 * return 0 on success, -1 on failure
430 */
431 int xc_domain_send_trigger(int xc_handle,
432 uint32_t domid,
433 uint32_t trigger,
434 uint32_t vcpu);
436 /**
437 * This function enables or disable debugging of a domain.
438 *
439 * @parm xc_handle a handle to an open hypervisor interface
440 * @parm domid the domain id to send trigger
441 * @parm enable true to enable debugging
442 * return 0 on success, -1 on failure
443 */
444 int xc_domain_setdebugging(int xc_handle,
445 uint32_t domid,
446 unsigned int enable);
448 /*
449 * EVENT CHANNEL FUNCTIONS
450 */
452 /* A port identifier is guaranteed to fit in 31 bits. */
453 typedef int evtchn_port_or_error_t;
455 /**
456 * This function allocates an unbound port. Ports are named endpoints used for
457 * interdomain communication. This function is most useful in opening a
458 * well-known port within a domain to receive events on.
459 *
460 * NOTE: If you are allocating a *local* unbound port, you probably want to
461 * use xc_evtchn_bind_unbound_port(). This function is intended for allocating
462 * ports *only* during domain creation.
463 *
464 * @parm xc_handle a handle to an open hypervisor interface
465 * @parm dom the ID of the local domain (the 'allocatee')
466 * @parm remote_dom the ID of the domain who will later bind
467 * @return allocated port (in @dom) on success, -1 on failure
468 */
469 evtchn_port_or_error_t
470 xc_evtchn_alloc_unbound(int xc_handle,
471 uint32_t dom,
472 uint32_t remote_dom);
474 int xc_evtchn_reset(int xc_handle,
475 uint32_t dom);
477 /*
478 * Return a handle to the event channel driver, or -1 on failure, in which case
479 * errno will be set appropriately.
480 */
481 int xc_evtchn_open(void);
483 /*
484 * Close a handle previously allocated with xc_evtchn_open().
485 */
486 int xc_evtchn_close(int xce_handle);
488 /*
489 * Return an fd that can be select()ed on for further calls to
490 * xc_evtchn_pending().
491 */
492 int xc_evtchn_fd(int xce_handle);
494 /*
495 * Notify the given event channel. Returns -1 on failure, in which case
496 * errno will be set appropriately.
497 */
498 int xc_evtchn_notify(int xce_handle, evtchn_port_t port);
500 /*
501 * Returns a new event port awaiting interdomain connection from the given
502 * domain ID, or -1 on failure, in which case errno will be set appropriately.
503 */
504 evtchn_port_or_error_t
505 xc_evtchn_bind_unbound_port(int xce_handle, int domid);
507 /*
508 * Returns a new event port bound to the remote port for the given domain ID,
509 * or -1 on failure, in which case errno will be set appropriately.
510 */
511 evtchn_port_or_error_t
512 xc_evtchn_bind_interdomain(int xce_handle, int domid,
513 evtchn_port_t remote_port);
515 /*
516 * Bind an event channel to the given VIRQ. Returns the event channel bound to
517 * the VIRQ, or -1 on failure, in which case errno will be set appropriately.
518 */
519 evtchn_port_or_error_t
520 xc_evtchn_bind_virq(int xce_handle, unsigned int virq);
522 /*
523 * Unbind the given event channel. Returns -1 on failure, in which case errno
524 * will be set appropriately.
525 */
526 int xc_evtchn_unbind(int xce_handle, evtchn_port_t port);
528 /*
529 * Return the next event channel to become pending, or -1 on failure, in which
530 * case errno will be set appropriately.
531 */
532 evtchn_port_or_error_t
533 xc_evtchn_pending(int xce_handle);
535 /*
536 * Unmask the given event channel. Returns -1 on failure, in which case errno
537 * will be set appropriately.
538 */
539 int xc_evtchn_unmask(int xce_handle, evtchn_port_t port);
541 int xc_physdev_pci_access_modify(int xc_handle,
542 uint32_t domid,
543 int bus,
544 int dev,
545 int func,
546 int enable);
548 int xc_readconsolering(int xc_handle,
549 char **pbuffer,
550 unsigned int *pnr_chars,
551 int clear);
553 int xc_send_debug_keys(int xc_handle, char *keys);
555 typedef xen_sysctl_physinfo_t xc_physinfo_t;
556 typedef uint32_t xc_cpu_to_node_t;
557 int xc_physinfo(int xc_handle,
558 xc_physinfo_t *info);
560 int xc_sched_id(int xc_handle,
561 int *sched_id);
563 typedef xen_sysctl_cpuinfo_t xc_cpuinfo_t;
564 int xc_getcpuinfo(int xc_handle, int max_cpus,
565 xc_cpuinfo_t *info, int *nr_cpus);
567 int xc_domain_setmaxmem(int xc_handle,
568 uint32_t domid,
569 unsigned int max_memkb);
571 int xc_domain_set_memmap_limit(int xc_handle,
572 uint32_t domid,
573 unsigned long map_limitkb);
575 int xc_domain_set_time_offset(int xc_handle,
576 uint32_t domid,
577 int32_t time_offset_seconds);
579 int xc_domain_memory_increase_reservation(int xc_handle,
580 uint32_t domid,
581 unsigned long nr_extents,
582 unsigned int extent_order,
583 unsigned int address_bits,
584 xen_pfn_t *extent_start);
586 int xc_domain_memory_decrease_reservation(int xc_handle,
587 uint32_t domid,
588 unsigned long nr_extents,
589 unsigned int extent_order,
590 xen_pfn_t *extent_start);
592 int xc_domain_memory_populate_physmap(int xc_handle,
593 uint32_t domid,
594 unsigned long nr_extents,
595 unsigned int extent_order,
596 unsigned int address_bits,
597 xen_pfn_t *extent_start);
599 int xc_domain_ioport_permission(int xc_handle,
600 uint32_t domid,
601 uint32_t first_port,
602 uint32_t nr_ports,
603 uint32_t allow_access);
605 int xc_domain_irq_permission(int xc_handle,
606 uint32_t domid,
607 uint8_t pirq,
608 uint8_t allow_access);
610 int xc_domain_iomem_permission(int xc_handle,
611 uint32_t domid,
612 unsigned long first_mfn,
613 unsigned long nr_mfns,
614 uint8_t allow_access);
616 unsigned long xc_make_page_below_4G(int xc_handle, uint32_t domid,
617 unsigned long mfn);
619 typedef xen_sysctl_perfc_desc_t xc_perfc_desc_t;
620 typedef xen_sysctl_perfc_val_t xc_perfc_val_t;
621 /* IMPORTANT: The caller is responsible for mlock()'ing the @desc and @val
622 arrays. */
623 int xc_perfc_control(int xc_handle,
624 uint32_t op,
625 xc_perfc_desc_t *desc,
626 xc_perfc_val_t *val,
627 int *nbr_desc,
628 int *nbr_val);
630 /**
631 * Memory maps a range within one domain to a local address range. Mappings
632 * should be unmapped with munmap and should follow the same rules as mmap
633 * regarding page alignment. Returns NULL on failure.
634 *
635 * In Linux, the ring queue for the control channel is accessible by mapping
636 * the shared_info_frame (from xc_domain_getinfo()) + 2048. The structure
637 * stored there is of type control_if_t.
638 *
639 * @parm xc_handle a handle on an open hypervisor interface
640 * @parm dom the domain to map memory from
641 * @parm size the amount of memory to map (in multiples of page size)
642 * @parm prot same flag as in mmap().
643 * @parm mfn the frame address to map.
644 */
645 void *xc_map_foreign_range(int xc_handle, uint32_t dom,
646 int size, int prot,
647 unsigned long mfn );
649 void *xc_map_foreign_pages(int xc_handle, uint32_t dom, int prot,
650 const xen_pfn_t *arr, int num );
652 /**
653 * Like xc_map_foreign_pages(), except it can succeeed partially.
654 * When a page cannot be mapped, its PFN in @arr is or'ed with
655 * 0xF0000000 to indicate the error.
656 */
657 void *xc_map_foreign_batch(int xc_handle, uint32_t dom, int prot,
658 xen_pfn_t *arr, int num );
660 /**
661 * Translates a virtual address in the context of a given domain and
662 * vcpu returning the machine page frame number of the associated
663 * page.
664 *
665 * @parm xc_handle a handle on an open hypervisor interface
666 * @parm dom the domain to perform the translation in
667 * @parm vcpu the vcpu to perform the translation on
668 * @parm virt the virtual address to translate
669 */
670 unsigned long xc_translate_foreign_address(int xc_handle, uint32_t dom,
671 int vcpu, unsigned long long virt);
674 /**
675 * DEPRECATED. Avoid using this, as it does not correctly account for PFNs
676 * without a backing MFN.
677 */
678 int xc_get_pfn_list(int xc_handle, uint32_t domid, uint64_t *pfn_buf,
679 unsigned long max_pfns);
681 unsigned long xc_ia64_fpsr_default(void);
683 int xc_ia64_get_pfn_list(int xc_handle, uint32_t domid,
684 xen_pfn_t *pfn_buf,
685 unsigned int start_page, unsigned int nr_pages);
687 int xc_copy_to_domain_page(int xc_handle, uint32_t domid,
688 unsigned long dst_pfn, const char *src_page);
690 int xc_clear_domain_page(int xc_handle, uint32_t domid,
691 unsigned long dst_pfn);
693 long xc_get_max_pages(int xc_handle, uint32_t domid);
695 int xc_mmuext_op(int xc_handle, struct mmuext_op *op, unsigned int nr_ops,
696 domid_t dom);
698 int xc_memory_op(int xc_handle, int cmd, void *arg);
700 int xc_get_pfn_type_batch(int xc_handle, uint32_t dom,
701 int num, uint32_t *arr);
704 /* Get current total pages allocated to a domain. */
705 long xc_get_tot_pages(int xc_handle, uint32_t domid);
707 /**
708 * This function retrieves the the number of bytes available
709 * in the heap in a specific range of address-widths and nodes.
710 *
711 * @parm xc_handle a handle to an open hypervisor interface
712 * @parm domid the domain to query
713 * @parm min_width the smallest address width to query (0 if don't care)
714 * @parm max_width the largest address width to query (0 if don't care)
715 * @parm node the node to query (-1 for all)
716 * @parm *bytes caller variable to put total bytes counted
717 * @return 0 on success, <0 on failure.
718 */
719 int xc_availheap(int xc_handle, int min_width, int max_width, int node,
720 uint64_t *bytes);
722 /*
723 * Trace Buffer Operations
724 */
726 /**
727 * xc_tbuf_enable - enable tracing buffers
728 *
729 * @parm xc_handle a handle to an open hypervisor interface
730 * @parm cnt size of tracing buffers to create (in pages)
731 * @parm mfn location to store mfn of the trace buffers to
732 * @parm size location to store the size (in bytes) of a trace buffer to
733 *
734 * Gets the machine address of the trace pointer area and the size of the
735 * per CPU buffers.
736 */
737 int xc_tbuf_enable(int xc_handle, unsigned long pages,
738 unsigned long *mfn, unsigned long *size);
740 /*
741 * Disable tracing buffers.
742 */
743 int xc_tbuf_disable(int xc_handle);
745 /**
746 * This function sets the size of the trace buffers. Setting the size
747 * is currently a one-shot operation that may be performed either at boot
748 * time or via this interface, not both. The buffer size must be set before
749 * enabling tracing.
750 *
751 * @parm xc_handle a handle to an open hypervisor interface
752 * @parm size the size in pages per cpu for the trace buffers
753 * @return 0 on success, -1 on failure.
754 */
755 int xc_tbuf_set_size(int xc_handle, unsigned long size);
757 /**
758 * This function retrieves the current size of the trace buffers.
759 * Note that the size returned is in terms of bytes, not pages.
761 * @parm xc_handle a handle to an open hypervisor interface
762 * @parm size will contain the size in bytes for the trace buffers
763 * @return 0 on success, -1 on failure.
764 */
765 int xc_tbuf_get_size(int xc_handle, unsigned long *size);
767 int xc_tbuf_set_cpu_mask(int xc_handle, uint32_t mask);
769 int xc_tbuf_set_evt_mask(int xc_handle, uint32_t mask);
771 int xc_domctl(int xc_handle, struct xen_domctl *domctl);
772 int xc_sysctl(int xc_handle, struct xen_sysctl *sysctl);
774 int xc_version(int xc_handle, int cmd, void *arg);
776 int xc_acm_op(int xc_handle, int cmd, void *arg, unsigned long arg_size);
778 /**************************
779 * GRANT TABLE OPERATIONS *
780 **************************/
782 /*
783 * Return a handle to the grant table driver, or -1 on failure, in which case
784 * errno will be set appropriately.
785 */
786 int xc_gnttab_open(void);
788 /*
789 * Close a handle previously allocated with xc_gnttab_open().
790 */
791 int xc_gnttab_close(int xcg_handle);
793 /*
794 * Memory maps a grant reference from one domain to a local address range.
795 * Mappings should be unmapped with xc_gnttab_munmap. Returns NULL on failure.
796 *
797 * @parm xcg_handle a handle on an open grant table interface
798 * @parm domid the domain to map memory from
799 * @parm ref the grant reference ID to map
800 * @parm prot same flag as in mmap()
801 */
802 void *xc_gnttab_map_grant_ref(int xcg_handle,
803 uint32_t domid,
804 uint32_t ref,
805 int prot);
807 /**
808 * Memory maps one or more grant references from one or more domains to a
809 * contiguous local address range. Mappings should be unmapped with
810 * xc_gnttab_munmap. Returns NULL on failure.
811 *
812 * @parm xcg_handle a handle on an open grant table interface
813 * @parm count the number of grant references to be mapped
814 * @parm domids an array of @count domain IDs by which the corresponding @refs
815 * were granted
816 * @parm refs an array of @count grant references to be mapped
817 * @parm prot same flag as in mmap()
818 */
819 void *xc_gnttab_map_grant_refs(int xcg_handle,
820 uint32_t count,
821 uint32_t *domids,
822 uint32_t *refs,
823 int prot);
825 /*
826 * Unmaps the @count pages starting at @start_address, which were mapped by a
827 * call to xc_gnttab_map_grant_ref or xc_gnttab_map_grant_refs. Returns zero
828 * on success, otherwise sets errno and returns non-zero.
829 */
830 int xc_gnttab_munmap(int xcg_handle,
831 void *start_address,
832 uint32_t count);
834 int xc_hvm_set_pci_intx_level(
835 int xc_handle, domid_t dom,
836 uint8_t domain, uint8_t bus, uint8_t device, uint8_t intx,
837 unsigned int level);
838 int xc_hvm_set_isa_irq_level(
839 int xc_handle, domid_t dom,
840 uint8_t isa_irq,
841 unsigned int level);
843 int xc_hvm_set_pci_link_route(
844 int xc_handle, domid_t dom, uint8_t link, uint8_t isa_irq);
847 typedef enum {
848 XC_ERROR_NONE = 0,
849 XC_INTERNAL_ERROR = 1,
850 XC_INVALID_KERNEL = 2,
851 XC_INVALID_PARAM = 3,
852 XC_OUT_OF_MEMORY = 4,
853 } xc_error_code;
855 #define XC_MAX_ERROR_MSG_LEN 1024
856 typedef struct {
857 int code;
858 char message[XC_MAX_ERROR_MSG_LEN];
859 } xc_error;
861 /*
862 * Return a pointer to the last error. This pointer and the
863 * data pointed to are only valid until the next call to
864 * libxc.
865 */
866 const xc_error *xc_get_last_error(void);
868 /*
869 * Clear the last error
870 */
871 void xc_clear_last_error(void);
873 typedef void (*xc_error_handler)(const xc_error *err);
875 /*
876 * The default error handler which prints to stderr
877 */
878 void xc_default_error_handler(const xc_error *err);
880 /*
881 * Convert an error code into a text description
882 */
883 const char *xc_error_code_to_desc(int code);
885 /*
886 * Registers a callback to handle errors
887 */
888 xc_error_handler xc_set_error_handler(xc_error_handler handler);
890 int xc_set_hvm_param(int handle, domid_t dom, int param, unsigned long value);
891 int xc_get_hvm_param(int handle, domid_t dom, int param, unsigned long *value);
893 /* PowerPC specific. */
894 int xc_alloc_real_mode_area(int xc_handle,
895 uint32_t domid,
896 unsigned int log);
898 /* IA64 specific, nvram save */
899 int xc_ia64_save_to_nvram(int xc_handle, uint32_t dom);
901 /* IA64 specific, nvram init */
902 int xc_ia64_nvram_init(int xc_handle, char *dom_name, uint32_t dom);
904 #endif /* XENCTRL_H */