Return to xen_common.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw

Annotation of qemu/hw/xen_common.h, revision 1.1.1.4

1.1       root        1: #ifndef QEMU_HW_XEN_COMMON_H
                      2: #define QEMU_HW_XEN_COMMON_H 1
                      3: 
1.1.1.3   root        4: #include "config-host.h"
                      5: 
1.1       root        6: #include <stddef.h>
                      7: #include <inttypes.h>
                      8: 
                      9: #include <xenctrl.h>
                     10: #include <xs.h>
                     11: #include <xen/io/xenbus.h>
                     12: 
                     13: #include "hw.h"
                     14: #include "xen.h"
1.1.1.2   root       15: #include "qemu-queue.h"
1.1       root       16: 
                     17: /*
1.1.1.3   root       18:  * We don't support Xen prior to 3.3.0.
1.1       root       19:  */
1.1.1.3   root       20: 
                     21: /* Xen before 4.0 */
                     22: #if CONFIG_XEN_CTRL_INTERFACE_VERSION < 400
                     23: static inline void *xc_map_foreign_bulk(int xc_handle, uint32_t dom, int prot,
                     24:                                         xen_pfn_t *arr, int *err,
                     25:                                         unsigned int num)
                     26: {
                     27:     return xc_map_foreign_batch(xc_handle, dom, prot, arr, num);
                     28: }
1.1       root       29: #endif
1.1.1.3   root       30: 
                     31: 
                     32: /* Xen before 4.1 */
                     33: #if CONFIG_XEN_CTRL_INTERFACE_VERSION < 410
                     34: 
                     35: typedef int XenXC;
                     36: typedef int XenEvtchn;
                     37: typedef int XenGnttab;
                     38: 
                     39: #  define XC_INTERFACE_FMT "%i"
                     40: #  define XC_HANDLER_INITIAL_VALUE    -1
                     41: 
                     42: static inline XenEvtchn xen_xc_evtchn_open(void *logger,
                     43:                                            unsigned int open_flags)
                     44: {
                     45:     return xc_evtchn_open();
                     46: }
                     47: 
                     48: static inline XenGnttab xen_xc_gnttab_open(void *logger,
                     49:                                            unsigned int open_flags)
                     50: {
                     51:     return xc_gnttab_open();
                     52: }
                     53: 
                     54: static inline XenXC xen_xc_interface_open(void *logger, void *dombuild_logger,
                     55:                                           unsigned int open_flags)
                     56: {
                     57:     return xc_interface_open();
                     58: }
                     59: 
                     60: static inline int xc_fd(int xen_xc)
                     61: {
                     62:     return xen_xc;
                     63: }
                     64: 
                     65: 
                     66: static inline int xc_domain_populate_physmap_exact
                     67:     (XenXC xc_handle, uint32_t domid, unsigned long nr_extents,
                     68:      unsigned int extent_order, unsigned int mem_flags, xen_pfn_t *extent_start)
                     69: {
                     70:     return xc_domain_memory_populate_physmap
                     71:         (xc_handle, domid, nr_extents, extent_order, mem_flags, extent_start);
                     72: }
                     73: 
                     74: static inline int xc_domain_add_to_physmap(int xc_handle, uint32_t domid,
                     75:                                            unsigned int space, unsigned long idx,
                     76:                                            xen_pfn_t gpfn)
                     77: {
                     78:     struct xen_add_to_physmap xatp = {
                     79:         .domid = domid,
                     80:         .space = space,
                     81:         .idx = idx,
                     82:         .gpfn = gpfn,
                     83:     };
                     84: 
                     85:     return xc_memory_op(xc_handle, XENMEM_add_to_physmap, &xatp);
                     86: }
                     87: 
                     88: static inline struct xs_handle *xs_open(unsigned long flags)
                     89: {
                     90:     return xs_daemon_open();
                     91: }
                     92: 
                     93: static inline void xs_close(struct xs_handle *xsh)
                     94: {
                     95:     if (xsh != NULL) {
                     96:         xs_daemon_close(xsh);
                     97:     }
                     98: }
                     99: 
                    100: 
                    101: /* Xen 4.1 */
                    102: #else
                    103: 
                    104: typedef xc_interface *XenXC;
                    105: typedef xc_evtchn *XenEvtchn;
                    106: typedef xc_gnttab *XenGnttab;
                    107: 
                    108: #  define XC_INTERFACE_FMT "%p"
                    109: #  define XC_HANDLER_INITIAL_VALUE    NULL
                    110: 
                    111: static inline XenEvtchn xen_xc_evtchn_open(void *logger,
                    112:                                            unsigned int open_flags)
                    113: {
                    114:     return xc_evtchn_open(logger, open_flags);
                    115: }
                    116: 
                    117: static inline XenGnttab xen_xc_gnttab_open(void *logger,
                    118:                                            unsigned int open_flags)
                    119: {
                    120:     return xc_gnttab_open(logger, open_flags);
                    121: }
                    122: 
                    123: static inline XenXC xen_xc_interface_open(void *logger, void *dombuild_logger,
                    124:                                           unsigned int open_flags)
                    125: {
                    126:     return xc_interface_open(logger, dombuild_logger, open_flags);
                    127: }
                    128: 
                    129: /* FIXME There is now way to have the xen fd */
                    130: static inline int xc_fd(xc_interface *xen_xc)
                    131: {
                    132:     return -1;
                    133: }
1.1       root      134: #endif
                    135: 
1.1.1.4 ! root      136: /* Xen before 4.2 */
        !           137: #if CONFIG_XEN_CTRL_INTERFACE_VERSION < 420
        !           138: static inline int xen_xc_hvm_inject_msi(XenXC xen_xc, domid_t dom,
        !           139:         uint64_t addr, uint32_t data)
        !           140: {
        !           141:     return -ENOSYS;
        !           142: }
        !           143: #else
        !           144: static inline int xen_xc_hvm_inject_msi(XenXC xen_xc, domid_t dom,
        !           145:         uint64_t addr, uint32_t data)
        !           146: {
        !           147:     return xc_hvm_inject_msi(xen_xc, dom, addr, data);
        !           148: }
        !           149: #endif
        !           150: 
        !           151: void destroy_hvm_domain(bool reboot);
1.1.1.3   root      152: 
1.1       root      153: #endif /* QEMU_HW_XEN_COMMON_H */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.