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.3

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.3 ! root      136: void destroy_hvm_domain(void);
        !           137: 
1.1       root      138: #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.