direct-io.hg

view tools/libxc/xenctrl.h @ 14101:3dac99b6034e

Xen coredump format: ELF formatified with note section.
added PFN-GMFN table for non-auto translated physmap
added PFN table for auto translated physmap.
HVM domain support.
IA64 support

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>

Use the guest's own p2m table instead of xc_get_pfn_list(), which
cannot handle PFNs with no MFN.
Dump a zeroed page for PFNs with no MFN.
Clearly deprecate xc_get_pfn_list().
Do not include a P2M table with HVM domains.
Refuse to dump HVM until we can map its pages with PFNs.

Signed-off-by: John Levon <john.levon@sun.com>
author Keir Fraser <keir@xensource.com>
date Sat Feb 24 14:31:42 2007 +0000 (2007-02-24)
parents 6c938630de54
children 270a5e2ead43
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 */
9 #ifndef XENCTRL_H
10 #define XENCTRL_H
12 /* Tell the Xen public headers we are a user-space tools build. */
13 #ifndef __XEN_TOOLS__
14 #define __XEN_TOOLS__ 1
15 #endif
17 #include <stddef.h>
18 #include <stdint.h>
19 #include <xen/xen.h>
20 #include <xen/domctl.h>
21 #include <xen/sysctl.h>
22 #include <xen/version.h>
23 #include <xen/event_channel.h>
24 #include <xen/sched.h>
25 #include <xen/memory.h>
26 #include <xen/acm.h>
27 #include <xen/acm_ops.h>
29 #ifdef __ia64__
30 #define XC_PAGE_SHIFT 14
31 #else
32 #define XC_PAGE_SHIFT 12
33 #endif
34 #define XC_PAGE_SIZE (1UL << XC_PAGE_SHIFT)
35 #define XC_PAGE_MASK (~(XC_PAGE_SIZE-1))
37 /*
38 * DEFINITIONS FOR CPU BARRIERS
39 */
41 #if defined(__i386__)
42 #define mb() __asm__ __volatile__ ( "lock; addl $0,0(%%esp)" : : : "memory" )
43 #define rmb() __asm__ __volatile__ ( "lock; addl $0,0(%%esp)" : : : "memory" )
44 #define wmb() __asm__ __volatile__ ( "" : : : "memory")
45 #elif defined(__x86_64__)
46 #define mb() __asm__ __volatile__ ( "mfence" : : : "memory")
47 #define rmb() __asm__ __volatile__ ( "lfence" : : : "memory")
48 #define wmb() __asm__ __volatile__ ( "" : : : "memory")
49 #elif defined(__ia64__)
50 #define mb() __asm__ __volatile__ ("mf" ::: "memory")
51 #define rmb() __asm__ __volatile__ ("mf" ::: "memory")
52 #define wmb() __asm__ __volatile__ ("mf" ::: "memory")
53 #elif defined(__powerpc__)
54 /* XXX loosen these up later */
55 #define mb() __asm__ __volatile__ ("sync" : : : "memory")
56 #define rmb() __asm__ __volatile__ ("sync" : : : "memory") /* lwsync? */
57 #define wmb() __asm__ __volatile__ ("sync" : : : "memory") /* eieio? */
58 #else
59 #error "Define barriers"
60 #endif
62 /*
63 * INITIALIZATION FUNCTIONS
64 */
66 /**
67 * This function opens a handle to the hypervisor interface. This function can
68 * be called multiple times within a single process. Multiple processes can
69 * have an open hypervisor interface at the same time.
70 *
71 * Each call to this function should have a corresponding call to
72 * xc_interface_close().
73 *
74 * This function can fail if the caller does not have superuser permission or
75 * if a Xen-enabled kernel is not currently running.
76 *
77 * @return a handle to the hypervisor interface or -1 on failure
78 */
79 int xc_interface_open(void);
81 /**
82 * This function closes an open hypervisor interface.
83 *
84 * This function can fail if the handle does not represent an open interface or
85 * if there were problems closing the interface.
86 *
87 * @parm xc_handle a handle to an open hypervisor interface
88 * @return 0 on success, -1 otherwise.
89 */
90 int xc_interface_close(int xc_handle);
92 /*
93 * KERNEL INTERFACES
94 */
96 /*
97 * Resolve a kernel device name (e.g., "evtchn", "blktap0") into a kernel
98 * device number. Returns -1 on error (and sets errno).
99 */
100 int xc_find_device_number(const char *name);
102 /*
103 * DOMAIN DEBUGGING FUNCTIONS
104 */
106 typedef struct xc_core_header {
107 unsigned int xch_magic;
108 unsigned int xch_nr_vcpus;
109 unsigned int xch_nr_pages;
110 unsigned int xch_ctxt_offset;
111 unsigned int xch_index_offset;
112 unsigned int xch_pages_offset;
113 } xc_core_header_t;
115 #define XC_CORE_MAGIC 0xF00FEBED
116 #define XC_CORE_MAGIC_HVM 0xF00FEBEE
118 #ifdef __linux__
120 #include <sys/ptrace.h>
121 #include <thread_db.h>
123 typedef void (*thr_ev_handler_t)(long);
125 void xc_register_event_handler(
126 thr_ev_handler_t h,
127 td_event_e e);
129 long xc_ptrace(
130 int xc_handle,
131 enum __ptrace_request request,
132 uint32_t domid,
133 long addr,
134 long data);
136 int xc_waitdomain(
137 int xc_handle,
138 int domain,
139 int *status,
140 int options);
142 #endif /* __linux__ */
144 /*
145 * DOMAIN MANAGEMENT FUNCTIONS
146 */
148 typedef struct xc_dominfo {
149 uint32_t domid;
150 uint32_t ssidref;
151 unsigned int dying:1, crashed:1, shutdown:1,
152 paused:1, blocked:1, running:1,
153 hvm:1;
154 unsigned int shutdown_reason; /* only meaningful if shutdown==1 */
155 unsigned long nr_pages;
156 unsigned long shared_info_frame;
157 uint64_t cpu_time;
158 unsigned long max_memkb;
159 unsigned int nr_online_vcpus;
160 unsigned int max_vcpu_id;
161 xen_domain_handle_t handle;
162 } xc_dominfo_t;
164 typedef xen_domctl_getdomaininfo_t xc_domaininfo_t;
165 int xc_domain_create(int xc_handle,
166 uint32_t ssidref,
167 xen_domain_handle_t handle,
168 uint32_t flags,
169 uint32_t *pdomid);
172 /* Functions to produce a dump of a given domain
173 * xc_domain_dumpcore - produces a dump to a specified file
174 * xc_domain_dumpcore_via_callback - produces a dump, using a specified
175 * callback function
176 */
177 int xc_domain_dumpcore(int xc_handle,
178 uint32_t domid,
179 const char *corename);
181 /* Define the callback function type for xc_domain_dumpcore_via_callback.
182 *
183 * This function is called by the coredump code for every "write",
184 * and passes an opaque object for the use of the function and
185 * created by the caller of xc_domain_dumpcore_via_callback.
186 */
187 typedef int (dumpcore_rtn_t)(void *arg, char *buffer, unsigned int length);
189 int xc_domain_dumpcore_via_callback(int xc_handle,
190 uint32_t domid,
191 void *arg,
192 dumpcore_rtn_t dump_rtn);
194 /*
195 * This function sets the maximum number of vcpus that a domain may create.
196 *
197 * @parm xc_handle a handle to an open hypervisor interface.
198 * @parm domid the domain id in which vcpus are to be created.
199 * @parm max the maximum number of vcpus that the domain may create.
200 * @return 0 on success, -1 on failure.
201 */
202 int xc_domain_max_vcpus(int xc_handle,
203 uint32_t domid,
204 unsigned int max);
206 /**
207 * This function pauses a domain. A paused domain still exists in memory
208 * however it does not receive any timeslices from the hypervisor.
209 *
210 * @parm xc_handle a handle to an open hypervisor interface
211 * @parm domid the domain id to pause
212 * @return 0 on success, -1 on failure.
213 */
214 int xc_domain_pause(int xc_handle,
215 uint32_t domid);
216 /**
217 * This function unpauses a domain. The domain should have been previously
218 * paused.
219 *
220 * @parm xc_handle a handle to an open hypervisor interface
221 * @parm domid the domain id to unpause
222 * return 0 on success, -1 on failure
223 */
224 int xc_domain_unpause(int xc_handle,
225 uint32_t domid);
227 /**
228 * This function will destroy a domain. Destroying a domain removes the domain
229 * completely from memory. This function should be called after sending the
230 * domain a SHUTDOWN control message to free up the domain resources.
231 *
232 * @parm xc_handle a handle to an open hypervisor interface
233 * @parm domid the domain id to destroy
234 * @return 0 on success, -1 on failure
235 */
236 int xc_domain_destroy(int xc_handle,
237 uint32_t domid);
240 /**
241 * This function resumes a suspended domain. The domain should have
242 * been previously suspended.
243 *
244 * @parm xc_handle a handle to an open hypervisor interface
245 * @parm domid the domain id to resume
246 * return 0 on success, -1 on failure
247 */
248 int xc_domain_resume(int xc_handle,
249 uint32_t domid);
251 /**
252 * This function will shutdown a domain. This is intended for use in
253 * fully-virtualized domains where this operation is analogous to the
254 * sched_op operations in a paravirtualized domain. The caller is
255 * expected to give the reason for the shutdown.
256 *
257 * @parm xc_handle a handle to an open hypervisor interface
258 * @parm domid the domain id to destroy
259 * @parm reason is the reason (SHUTDOWN_xxx) for the shutdown
260 * @return 0 on success, -1 on failure
261 */
262 int xc_domain_shutdown(int xc_handle,
263 uint32_t domid,
264 int reason);
266 int xc_vcpu_setaffinity(int xc_handle,
267 uint32_t domid,
268 int vcpu,
269 uint64_t cpumap);
270 int xc_vcpu_getaffinity(int xc_handle,
271 uint32_t domid,
272 int vcpu,
273 uint64_t *cpumap);
275 /**
276 * This function will return information about one or more domains. It is
277 * designed to iterate over the list of domains. If a single domain is
278 * requested, this function will return the next domain in the list - if
279 * one exists. It is, therefore, important in this case to make sure the
280 * domain requested was the one returned.
281 *
282 * @parm xc_handle a handle to an open hypervisor interface
283 * @parm first_domid the first domain to enumerate information from. Domains
284 * are currently enumerate in order of creation.
285 * @parm max_doms the number of elements in info
286 * @parm info an array of max_doms size that will contain the information for
287 * the enumerated domains.
288 * @return the number of domains enumerated or -1 on error
289 */
290 int xc_domain_getinfo(int xc_handle,
291 uint32_t first_domid,
292 unsigned int max_doms,
293 xc_dominfo_t *info);
296 /**
297 * This function will set the execution context for the specified vcpu.
298 *
299 * @parm xc_handle a handle to an open hypervisor interface
300 * @parm domid the domain to set the vcpu context for
301 * @parm vcpu the vcpu number for the context
302 * @parm ctxt pointer to the the cpu context with the values to set
303 * @return the number of domains enumerated or -1 on error
304 */
305 int xc_vcpu_setcontext(int xc_handle,
306 uint32_t domid,
307 uint32_t vcpu,
308 vcpu_guest_context_t *ctxt);
309 /**
310 * This function will return information about one or more domains, using a
311 * single hypercall. The domain information will be stored into the supplied
312 * array of xc_domaininfo_t structures.
313 *
314 * @parm xc_handle a handle to an open hypervisor interface
315 * @parm first_domain the first domain to enumerate information from.
316 * Domains are currently enumerate in order of creation.
317 * @parm max_domains the number of elements in info
318 * @parm info an array of max_doms size that will contain the information for
319 * the enumerated domains.
320 * @return the number of domains enumerated or -1 on error
321 */
322 int xc_domain_getinfolist(int xc_handle,
323 uint32_t first_domain,
324 unsigned int max_domains,
325 xc_domaininfo_t *info);
327 /**
328 * This function returns information about the context of a hvm domain
329 * @parm xc_handle a handle to an open hypervisor interface
330 * @parm domid the domain to get information from
331 * @parm ctxt_buf a pointer to a structure to store the execution context of
332 * the hvm domain
333 * @parm size the size of ctxt_buf in bytes
334 * @return 0 on success, -1 on failure
335 */
336 int xc_domain_hvm_getcontext(int xc_handle,
337 uint32_t domid,
338 uint8_t *ctxt_buf,
339 uint32_t size);
341 /**
342 * This function will set the context for hvm domain
343 *
344 * @parm xc_handle a handle to an open hypervisor interface
345 * @parm domid the domain to set the hvm domain context for
346 * @parm hvm_ctxt pointer to the the hvm context with the values to set
347 * @parm size the size of hvm_ctxt in bytes
348 * @return 0 on success, -1 on failure
349 */
350 int xc_domain_hvm_setcontext(int xc_handle,
351 uint32_t domid,
352 uint8_t *hvm_ctxt,
353 uint32_t size);
355 /**
356 * This function returns information about the execution context of a
357 * particular vcpu of a domain.
358 *
359 * @parm xc_handle a handle to an open hypervisor interface
360 * @parm domid the domain to get information from
361 * @parm vcpu the vcpu number
362 * @parm ctxt a pointer to a structure to store the execution context of the
363 * domain
364 * @return 0 on success, -1 on failure
365 */
366 int xc_vcpu_getcontext(int xc_handle,
367 uint32_t domid,
368 uint32_t vcpu,
369 vcpu_guest_context_t *ctxt);
371 typedef xen_domctl_getvcpuinfo_t xc_vcpuinfo_t;
372 int xc_vcpu_getinfo(int xc_handle,
373 uint32_t domid,
374 uint32_t vcpu,
375 xc_vcpuinfo_t *info);
377 int xc_domain_setcpuweight(int xc_handle,
378 uint32_t domid,
379 float weight);
380 long long xc_domain_get_cpu_usage(int xc_handle,
381 domid_t domid,
382 int vcpu);
384 int xc_domain_sethandle(int xc_handle, uint32_t domid,
385 xen_domain_handle_t handle);
387 typedef xen_domctl_shadow_op_stats_t xc_shadow_op_stats_t;
388 int xc_shadow_control(int xc_handle,
389 uint32_t domid,
390 unsigned int sop,
391 unsigned long *dirty_bitmap,
392 unsigned long pages,
393 unsigned long *mb,
394 uint32_t mode,
395 xc_shadow_op_stats_t *stats);
397 int xc_sedf_domain_set(int xc_handle,
398 uint32_t domid,
399 uint64_t period, uint64_t slice,
400 uint64_t latency, uint16_t extratime,
401 uint16_t weight);
403 int xc_sedf_domain_get(int xc_handle,
404 uint32_t domid,
405 uint64_t* period, uint64_t *slice,
406 uint64_t *latency, uint16_t *extratime,
407 uint16_t *weight);
409 int xc_sched_credit_domain_set(int xc_handle,
410 uint32_t domid,
411 struct xen_domctl_sched_credit *sdom);
413 int xc_sched_credit_domain_get(int xc_handle,
414 uint32_t domid,
415 struct xen_domctl_sched_credit *sdom);
417 /**
418 * This function sends a trigger to a domain.
419 *
420 * @parm xc_handle a handle to an open hypervisor interface
421 * @parm domid the domain id to send trigger
422 * @parm trigger the trigger type
423 * @parm vcpu the vcpu number to send trigger
424 * return 0 on success, -1 on failure
425 */
426 int xc_domain_send_trigger(int xc_handle,
427 uint32_t domid,
428 uint32_t trigger,
429 uint32_t vcpu);
431 /*
432 * EVENT CHANNEL FUNCTIONS
433 */
435 /**
436 * This function allocates an unbound port. Ports are named endpoints used for
437 * interdomain communication. This function is most useful in opening a
438 * well-known port within a domain to receive events on.
439 *
440 * NOTE: If you are allocating a *local* unbound port, you probably want to
441 * use xc_evtchn_bind_unbound_port(). This function is intended for allocating
442 * ports *only* during domain creation.
443 *
444 * @parm xc_handle a handle to an open hypervisor interface
445 * @parm dom the ID of the local domain (the 'allocatee')
446 * @parm remote_dom the ID of the domain who will later bind
447 * @return allocated port (in @dom) on success, -1 on failure
448 */
449 int xc_evtchn_alloc_unbound(int xc_handle,
450 uint32_t dom,
451 uint32_t remote_dom);
453 int xc_evtchn_reset(int xc_handle,
454 uint32_t dom);
456 int xc_physdev_pci_access_modify(int xc_handle,
457 uint32_t domid,
458 int bus,
459 int dev,
460 int func,
461 int enable);
463 int xc_readconsolering(int xc_handle,
464 char **pbuffer,
465 unsigned int *pnr_chars,
466 int clear);
468 typedef xen_sysctl_physinfo_t xc_physinfo_t;
469 int xc_physinfo(int xc_handle,
470 xc_physinfo_t *info);
472 int xc_sched_id(int xc_handle,
473 int *sched_id);
475 int xc_domain_setmaxmem(int xc_handle,
476 uint32_t domid,
477 unsigned int max_memkb);
479 int xc_domain_set_memmap_limit(int xc_handle,
480 uint32_t domid,
481 unsigned long map_limitkb);
483 int xc_domain_set_time_offset(int xc_handle,
484 uint32_t domid,
485 int32_t time_offset_seconds);
487 int xc_domain_memory_increase_reservation(int xc_handle,
488 uint32_t domid,
489 unsigned long nr_extents,
490 unsigned int extent_order,
491 unsigned int address_bits,
492 xen_pfn_t *extent_start);
494 int xc_domain_memory_decrease_reservation(int xc_handle,
495 uint32_t domid,
496 unsigned long nr_extents,
497 unsigned int extent_order,
498 xen_pfn_t *extent_start);
500 int xc_domain_memory_populate_physmap(int xc_handle,
501 uint32_t domid,
502 unsigned long nr_extents,
503 unsigned int extent_order,
504 unsigned int address_bits,
505 xen_pfn_t *extent_start);
507 int xc_domain_ioport_permission(int xc_handle,
508 uint32_t domid,
509 uint32_t first_port,
510 uint32_t nr_ports,
511 uint32_t allow_access);
513 int xc_domain_irq_permission(int xc_handle,
514 uint32_t domid,
515 uint8_t pirq,
516 uint8_t allow_access);
518 int xc_domain_iomem_permission(int xc_handle,
519 uint32_t domid,
520 unsigned long first_mfn,
521 unsigned long nr_mfns,
522 uint8_t allow_access);
524 unsigned long xc_make_page_below_4G(int xc_handle, uint32_t domid,
525 unsigned long mfn);
527 typedef xen_sysctl_perfc_desc_t xc_perfc_desc_t;
528 typedef xen_sysctl_perfc_val_t xc_perfc_val_t;
529 /* IMPORTANT: The caller is responsible for mlock()'ing the @desc and @val
530 arrays. */
531 int xc_perfc_control(int xc_handle,
532 uint32_t op,
533 xc_perfc_desc_t *desc,
534 xc_perfc_val_t *val,
535 int *nbr_desc,
536 int *nbr_val);
538 /**
539 * Memory maps a range within one domain to a local address range. Mappings
540 * should be unmapped with munmap and should follow the same rules as mmap
541 * regarding page alignment. Returns NULL on failure.
542 *
543 * In Linux, the ring queue for the control channel is accessible by mapping
544 * the shared_info_frame (from xc_domain_getinfo()) + 2048. The structure
545 * stored there is of type control_if_t.
546 *
547 * @parm xc_handle a handle on an open hypervisor interface
548 * @parm dom the domain to map memory from
549 * @parm size the amount of memory to map (in multiples of page size)
550 * @parm prot same flag as in mmap().
551 * @parm mfn the frame address to map.
552 */
553 void *xc_map_foreign_range(int xc_handle, uint32_t dom,
554 int size, int prot,
555 unsigned long mfn );
557 void *xc_map_foreign_batch(int xc_handle, uint32_t dom, int prot,
558 xen_pfn_t *arr, int num );
560 /**
561 * Translates a virtual address in the context of a given domain and
562 * vcpu returning the machine page frame number of the associated
563 * page.
564 *
565 * @parm xc_handle a handle on an open hypervisor interface
566 * @parm dom the domain to perform the translation in
567 * @parm vcpu the vcpu to perform the translation on
568 * @parm virt the virtual address to translate
569 */
570 unsigned long xc_translate_foreign_address(int xc_handle, uint32_t dom,
571 int vcpu, unsigned long long virt);
574 /**
575 * DEPRECATED. Avoid using this, as it does not correctly account for PFNs
576 * without a backing MFN.
577 */
578 int xc_get_pfn_list(int xc_handle, uint32_t domid, uint64_t *pfn_buf,
579 unsigned long max_pfns);
581 unsigned long xc_ia64_fpsr_default(void);
583 int xc_ia64_get_pfn_list(int xc_handle, uint32_t domid,
584 xen_pfn_t *pfn_buf,
585 unsigned int start_page, unsigned int nr_pages);
587 int xc_copy_to_domain_page(int xc_handle, uint32_t domid,
588 unsigned long dst_pfn, const char *src_page);
590 int xc_clear_domain_page(int xc_handle, uint32_t domid,
591 unsigned long dst_pfn);
593 long xc_get_max_pages(int xc_handle, uint32_t domid);
595 int xc_mmuext_op(int xc_handle, struct mmuext_op *op, unsigned int nr_ops,
596 domid_t dom);
598 int xc_memory_op(int xc_handle, int cmd, void *arg);
600 int xc_get_pfn_type_batch(int xc_handle, uint32_t dom,
601 int num, uint32_t *arr);
604 /* Get current total pages allocated to a domain. */
605 long xc_get_tot_pages(int xc_handle, uint32_t domid);
608 /*
609 * Trace Buffer Operations
610 */
612 /**
613 * xc_tbuf_enable - enable tracing buffers
614 *
615 * @parm xc_handle a handle to an open hypervisor interface
616 * @parm cnt size of tracing buffers to create (in pages)
617 * @parm mfn location to store mfn of the trace buffers to
618 * @parm size location to store the size (in bytes) of a trace buffer to
619 *
620 * Gets the machine address of the trace pointer area and the size of the
621 * per CPU buffers.
622 */
623 int xc_tbuf_enable(int xc_handle, unsigned long pages,
624 unsigned long *mfn, unsigned long *size);
626 /*
627 * Disable tracing buffers.
628 */
629 int xc_tbuf_disable(int xc_handle);
631 /**
632 * This function sets the size of the trace buffers. Setting the size
633 * is currently a one-shot operation that may be performed either at boot
634 * time or via this interface, not both. The buffer size must be set before
635 * enabling tracing.
636 *
637 * @parm xc_handle a handle to an open hypervisor interface
638 * @parm size the size in pages per cpu for the trace buffers
639 * @return 0 on success, -1 on failure.
640 */
641 int xc_tbuf_set_size(int xc_handle, unsigned long size);
643 /**
644 * This function retrieves the current size of the trace buffers.
645 * Note that the size returned is in terms of bytes, not pages.
647 * @parm xc_handle a handle to an open hypervisor interface
648 * @parm size will contain the size in bytes for the trace buffers
649 * @return 0 on success, -1 on failure.
650 */
651 int xc_tbuf_get_size(int xc_handle, unsigned long *size);
653 int xc_tbuf_set_cpu_mask(int xc_handle, uint32_t mask);
655 int xc_tbuf_set_evt_mask(int xc_handle, uint32_t mask);
657 int xc_domctl(int xc_handle, struct xen_domctl *domctl);
658 int xc_sysctl(int xc_handle, struct xen_sysctl *sysctl);
660 int xc_version(int xc_handle, int cmd, void *arg);
662 /*
663 * MMU updates.
664 */
665 #define MAX_MMU_UPDATES 1024
666 struct xc_mmu {
667 mmu_update_t updates[MAX_MMU_UPDATES];
668 int idx;
669 domid_t subject;
670 };
671 typedef struct xc_mmu xc_mmu_t;
672 xc_mmu_t *xc_init_mmu_updates(int xc_handle, domid_t dom);
673 int xc_add_mmu_update(int xc_handle, xc_mmu_t *mmu,
674 unsigned long long ptr, unsigned long long val);
675 int xc_finish_mmu_updates(int xc_handle, xc_mmu_t *mmu);
677 int xc_acm_op(int xc_handle, int cmd, void *arg, unsigned long arg_size);
679 /*
680 * Return a handle to the event channel driver, or -1 on failure, in which case
681 * errno will be set appropriately.
682 */
683 int xc_evtchn_open(void);
685 /*
686 * Close a handle previously allocated with xc_evtchn_open().
687 */
688 int xc_evtchn_close(int xce_handle);
690 /*
691 * Return an fd that can be select()ed on for further calls to
692 * xc_evtchn_pending().
693 */
694 int xc_evtchn_fd(int xce_handle);
696 /*
697 * Notify the given event channel. Returns -1 on failure, in which case
698 * errno will be set appropriately.
699 */
700 int xc_evtchn_notify(int xce_handle, evtchn_port_t port);
702 /*
703 * Returns a new event port awaiting interdomain connection from the given
704 * domain ID, or -1 on failure, in which case errno will be set appropriately.
705 */
706 evtchn_port_t xc_evtchn_bind_unbound_port(int xce_handle, int domid);
708 /*
709 * Returns a new event port bound to the remote port for the given domain ID,
710 * or -1 on failure, in which case errno will be set appropriately.
711 */
712 evtchn_port_t xc_evtchn_bind_interdomain(int xce_handle, int domid,
713 evtchn_port_t remote_port);
715 /*
716 * Unbind the given event channel. Returns -1 on failure, in which case errno
717 * will be set appropriately.
718 */
719 int xc_evtchn_unbind(int xce_handle, evtchn_port_t port);
721 /*
722 * Bind an event channel to the given VIRQ. Returns the event channel bound to
723 * the VIRQ, or -1 on failure, in which case errno will be set appropriately.
724 */
725 evtchn_port_t xc_evtchn_bind_virq(int xce_handle, unsigned int virq);
727 /*
728 * Return the next event channel to become pending, or -1 on failure, in which
729 * case errno will be set appropriately.
730 */
731 evtchn_port_t xc_evtchn_pending(int xce_handle);
733 /*
734 * Unmask the given event channel. Returns -1 on failure, in which case errno
735 * will be set appropriately.
736 */
737 int xc_evtchn_unmask(int xce_handle, evtchn_port_t port);
739 int xc_hvm_set_pci_intx_level(
740 int xc_handle, domid_t dom,
741 uint8_t domain, uint8_t bus, uint8_t device, uint8_t intx,
742 unsigned int level);
743 int xc_hvm_set_isa_irq_level(
744 int xc_handle, domid_t dom,
745 uint8_t isa_irq,
746 unsigned int level);
748 int xc_hvm_set_pci_link_route(
749 int xc_handle, domid_t dom, uint8_t link, uint8_t isa_irq);
752 typedef enum {
753 XC_ERROR_NONE = 0,
754 XC_INTERNAL_ERROR = 1,
755 XC_INVALID_KERNEL = 2,
756 XC_INVALID_PARAM = 3,
757 XC_OUT_OF_MEMORY = 4,
758 } xc_error_code;
760 #define XC_MAX_ERROR_MSG_LEN 1024
761 typedef struct {
762 int code;
763 char message[XC_MAX_ERROR_MSG_LEN];
764 } xc_error;
766 /*
767 * Return a pointer to the last error. This pointer and the
768 * data pointed to are only valid until the next call to
769 * libxc.
770 */
771 const xc_error const *xc_get_last_error(void);
773 /*
774 * Clear the last error
775 */
776 void xc_clear_last_error(void);
778 typedef void (*xc_error_handler)(const xc_error const* err);
780 /*
781 * The default error handler which prints to stderr
782 */
783 void xc_default_error_handler(const xc_error const* err);
785 /*
786 * Convert an error code into a text description
787 */
788 const char *xc_error_code_to_desc(int code);
790 /*
791 * Registers a callback to handle errors
792 */
793 xc_error_handler xc_set_error_handler(xc_error_handler handler);
795 /* PowerPC specific. */
796 int xc_alloc_real_mode_area(int xc_handle,
797 uint32_t domid,
798 unsigned int log);
799 #endif