WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-api

[Xen-API] [PATCH 4 of 4] REBASE-4.1: xiu: add xenctrlosdep backend

To: xen-api@xxxxxxxxxxxxxxxxxxx
Subject: [Xen-API] [PATCH 4 of 4] REBASE-4.1: xiu: add xenctrlosdep backend
From: Ian Campbell <ian.campbell@xxxxxxxxxx>
Date: Tue, 11 Jan 2011 10:56:06 +0000
Cc: gianni.tedesco@xxxxxxxxxx, zheng.li@xxxxxxxxxxxxx
Delivery-date: Tue, 11 Jan 2011 03:47:48 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxxx
In-reply-to: <patchbomb.1294743362@xxxxxxxxxxxxxxxxxxxxxx>
List-help: <mailto:xen-api-request@lists.xensource.com?subject=help>
List-id: Discussion of API issues surrounding Xen <xen-api.lists.xensource.com>
List-post: <mailto:xen-api@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/mailman/listinfo/xen-api>, <mailto:xen-api-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/mailman/listinfo/xen-api>, <mailto:xen-api-request@lists.xensource.com?subject=unsubscribe>
References: <patchbomb.1294743362@xxxxxxxxxxxxxxxxxxxxxx>
Sender: xen-api-bounces@xxxxxxxxxxxxxxxxxxx
User-agent: Mercurial-patchbomb/1.5.2
# HG changeset patch
# User root@xxxxxxxxxxxxxxxxxxxxx
# Date 1294651017 18000
# Node ID e7c8eaefec098d4b94a8d5bbad1528a795681a40
# Parent  bdd3258405c615d0fa81c6140d1340a1672247a6
REBASE-4.1: xiu: add xenctrlosdep backend.

This interface was recently added to the upstream libxenctrl to allow
interception of the calls to the hypervisor.

Convert eventchn/eventchn_injection.c and xc/xc_lib_injection.c into an XIU
backend for this interface.

(depends on global rebase to Xen 4.1)

Signed-off-by: Ian Campbell <ian.campbell@xxxxxxxxxx>

diff -r bdd3258405c6 -r e7c8eaefec09 Makefile.in
--- a/Makefile.in       Mon Jan 10 04:16:55 2011 -0500
+++ b/Makefile.in       Mon Jan 10 04:16:57 2011 -0500
@@ -56,6 +56,7 @@ endif
        $(MAKE) -C cpuid
        $(MAKE) -C vhd
        $(MAKE) -C tapctl
+       $(MAKE) -C fake
 endif
 
 install:
@@ -104,6 +105,7 @@ endif
        $(MAKE) -C cpuid install
        $(MAKE) -C vhd install
        $(MAKE) -C tapctl install
+       $(MAKE) -C fake install
 endif
 
 uninstall:
@@ -152,6 +154,7 @@ endif
        $(MAKE) -C cpuid uninstall
        $(MAKE) -C vhd uninstall
        $(MAKE) -C tapctl uninstall
+       $(MAKE) -C fake uninstall
 endif
 
 bins:
@@ -211,6 +214,7 @@ endif
        $(MAKE) -C cpuid doc
        $(MAKE) -C vhd doc
        $(MAKE) -C tapctl doc
+       $(MAKE) -C fake doc
        $(MAKE) -C xen-utils doc
 
 .PHONY: clean
@@ -239,6 +243,7 @@ endif
        $(MAKE) -C xen-utils clean
 
 cleanxen:
+       $(MAKE) -C fake clean
 ifeq ($(WITH_XEN_SYSTEM_BINDINGS),0)
        $(MAKE) -C mmap clean
 endif
diff -r bdd3258405c6 -r e7c8eaefec09 fake/Makefile
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/fake/Makefile     Mon Jan 10 04:16:57 2011 -0500
@@ -0,0 +1,27 @@
+CC := gcc
+
+CFLAGS := -O1
+CFLAGS += -fno-omit-frame-pointer -fno-optimize-sibling-calls 
-fno-strict-aliasing -std=gnu99
+CFLAGS += -mno-tls-direct-seg-refs
+CFLAGS += -Wall -Wstrict-prototypes -Wno-unused-value 
-Wdeclaration-after-statement -Werror -Wmissing-prototypes
+CFLAGS += -D__XEN_TOOLS__ -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 
-D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_GNU_SOURCE
+
+all: xenctrl_osdep_xiu.so
+       @:
+
+xeninterrcept_xiu.o: xenctrl_osdep_xiu.c
+       $(CC) $(CFLAGS) -c -o xenctrl_osdep_xiu.o xenctrl_osdep_xiu.c
+
+xenctrl_osdep_xiu.so: xenctrl_osdep_xiu.o
+       $(CC) $(CFLAGS) -shared -o xenctrl_osdep_xiu.so xenctrl_osdep_xiu.o 
-lxenctrl
+
+install: xenctrl_osdep_xiu.so
+       mkdir -p $$(DESTDIR)/opt/xensource/lib/xenctrl/
+       cp xenctrl_osdep_xiu.so 
$(DESTDIR)/opt/xensource/lib/xenctrl/osdep_xiu.so
+
+clean:
+       rm -f xeninterrcept_xiu.o
+       rm -f xenctrl_osdep_xiu.so
+
+uninstall:
+       rm -f $(DESTDIR)/opt/xensource/lib/xenctrl/osdep_xiu.so
diff -r bdd3258405c6 -r e7c8eaefec09 fake/xenctrl_osdep_xiu.c
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/fake/xenctrl_osdep_xiu.c  Mon Jan 10 04:16:57 2011 -0500
@@ -0,0 +1,609 @@
+/*
+ * Copyright (C) 2010 Citrix Systems Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <xenctrl.h>
+#include <xenctrlosdep.h>
+
+#include "marshall.h"
+
+#define IPRINTF(_x, _f, _a...) xc_osdep_log(_x,XTL_INFO,0, _f , ## _a)
+
+#define ERROR(_x, _m, _a...)  xc_osdep_log(_x,XTL_ERROR,XC_INTERNAL_ERROR,_m , 
## _a )
+#define PERROR(_x, _m, _a...) xc_osdep_log(_x,XTL_ERROR,XC_INTERNAL_ERROR,_m \
+                  " (%d = %s)", ## _a , errno, xc_strerror(xch, errno))
+
+#define HYPCALLcmd "hypcall"
+
+static xc_osdep_handle xiu_privcmd_open(xc_interface *xch)
+{
+    struct sockaddr_un remote;
+    char *s;
+    int fd, len;
+
+    s = getenv("XIU");
+    if (!s)
+    {
+        ERROR(xch, "XIU not found. Set $XIU");
+        return XC_OSDEP_OPEN_ERROR;
+    }
+
+    snprintf(remote.sun_path, 256, "%s-xc", s);
+    remote.sun_family = AF_UNIX;
+    len = strlen(remote.sun_path) + sizeof(remote.sun_family);
+
+    fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fd == -1)
+    {
+        ERROR(xch, "XIU: Cannot open Unix domain socket");
+        return XC_OSDEP_OPEN_ERROR;
+    }
+
+    if (connect(fd, (struct sockaddr *)&remote, len) != 0)
+    {
+        ERROR(xch, "XIU: Cannot connect to Unix domain socket %s.", 
remote.sun_path);
+        return XC_OSDEP_OPEN_ERROR;
+    }
+
+    return (xc_osdep_handle)fd;
+}
+
+static int xiu_privcmd_close(xc_interface *xch, xc_osdep_handle h)
+{
+    int fd = (int)h;
+    return close(fd);
+}
+
+#define DOMAINHANDLE 
"%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x"
+
+static int fake_xen_domctl(int fd, struct xen_domctl *domctl)
+{
+    #define DOMCTLcmd "domctl"
+    switch (domctl->cmd) {
+    case XEN_DOMCTL_pausedomain:
+    case XEN_DOMCTL_unpausedomain:
+    case XEN_DOMCTL_resumedomain:
+    case XEN_DOMCTL_destroydomain:
+        marshall_command(fd, "%s,%d,%d\n", DOMCTLcmd, domctl->cmd, 
domctl->domain);
+        return unmarshall_return(fd);
+    case XEN_DOMCTL_createdomain: /* W ssidref */
+        marshall_command(fd, "%s,%d,%d,%d," DOMAINHANDLE "\n", DOMCTLcmd,
+                         domctl->cmd,
+                         
(domctl->u.createdomain.flags|XEN_DOMCTL_CDF_hvm_guest)?1:0,
+                         (domctl->u.createdomain.flags|XEN_DOMCTL_CDF_hap)?1:0,
+                         domctl->u.createdomain.handle[0],
+                         domctl->u.createdomain.handle[1],
+                         domctl->u.createdomain.handle[2],
+                         domctl->u.createdomain.handle[3],
+                         domctl->u.createdomain.handle[4],
+                         domctl->u.createdomain.handle[5],
+                         domctl->u.createdomain.handle[6],
+                         domctl->u.createdomain.handle[7],
+                         domctl->u.createdomain.handle[8],
+                         domctl->u.createdomain.handle[9],
+                         domctl->u.createdomain.handle[10],
+                         domctl->u.createdomain.handle[11],
+                         domctl->u.createdomain.handle[12],
+                         domctl->u.createdomain.handle[13],
+                         domctl->u.createdomain.handle[14],
+                         domctl->u.createdomain.handle[15]);
+        domctl->domain = unmarshall_int(fd);
+        return unmarshall_return(fd);
+    case XEN_DOMCTL_max_mem: /* W domid, maxmem */
+        marshall_command(fd, "%s,%d,%d,%d\n", DOMCTLcmd,
+                         domctl->cmd,
+                         domctl->domain, domctl->u.max_mem.max_memkb);
+        return unmarshall_return(fd);
+    case XEN_DOMCTL_settimeoffset: /* W domid, time */
+        marshall_command(fd, "%s,%d,%d,%d\n", DOMCTLcmd,
+                         domctl->cmd,
+                         domctl->domain,
+                         domctl->u.settimeoffset.time_offset_seconds);
+        return unmarshall_return(fd);
+#ifdef XEN_DOMCTL_setvmxassist
+    case XEN_DOMCTL_setvmxassist: /* W domid, use_vmxassist */
+        marshall_command(fd, "%s,%d,%d,%d\n", DOMCTLcmd,
+                         domctl->cmd,
+                         domctl->domain,
+                         domctl->u.setvmxassist.use_vmxassist);
+        return unmarshall_return(fd);
+#endif
+    case XEN_DOMCTL_max_vcpus: /* W domid, max */
+        marshall_command(fd, "%s,%d,%d,%d\n", DOMCTLcmd,
+                         domctl->cmd,
+                         domctl->domain,
+                         domctl->u.max_vcpus.max);
+        return unmarshall_return(fd);
+    case XEN_DOMCTL_setdomainhandle: { /* domid, fd */
+        marshall_command(fd, "%s,%d,%d," DOMAINHANDLE "\n", DOMCTLcmd,
+                         domctl->cmd,
+                         domctl->domain,
+                         domctl->u.setdomainhandle.handle[0],
+                         domctl->u.setdomainhandle.handle[1],
+                         domctl->u.setdomainhandle.handle[2],
+                         domctl->u.setdomainhandle.handle[3],
+                         domctl->u.setdomainhandle.handle[4],
+                         domctl->u.setdomainhandle.handle[5],
+                         domctl->u.setdomainhandle.handle[6],
+                         domctl->u.setdomainhandle.handle[7],
+                         domctl->u.setdomainhandle.handle[8],
+                         domctl->u.setdomainhandle.handle[9],
+                         domctl->u.setdomainhandle.handle[10],
+                         domctl->u.setdomainhandle.handle[11],
+                         domctl->u.setdomainhandle.handle[12],
+                         domctl->u.setdomainhandle.handle[13],
+                         domctl->u.setdomainhandle.handle[14],
+                         domctl->u.setdomainhandle.handle[15]);
+        return unmarshall_return(fd);
+        }
+    /* just returning success : might need init */
+    case XEN_DOMCTL_getvcpucontext:
+    case XEN_DOMCTL_getvcpuaffinity:
+        return 0;
+    /* just returning success */
+    case XEN_DOMCTL_scheduler_op:
+        return 0;
+    case XEN_DOMCTL_shadow_op:
+        /* Only fd set/get allocation at the moment */
+        marshall_command(fd, "%s,%d,%d,%d,%d,%d\n", DOMCTLcmd,
+                 domctl->cmd,
+                 domctl->domain,
+                 domctl->u.shadow_op.op,
+                 domctl->u.shadow_op.mode,
+                 domctl->u.shadow_op.mb);
+        if(domctl->u.shadow_op.op == XEN_DOMCTL_SHADOW_OP_GET_ALLOCATION) 
+            domctl->u.shadow_op.mb = unmarshall_int(fd);
+
+        return unmarshall_return(fd);
+
+    /* just return success */
+    case XEN_DOMCTL_ioport_permission: 
+    case XEN_DOMCTL_irq_permission:
+    case XEN_DOMCTL_iomem_permission:
+    case XEN_DOMCTL_setvcpuaffinity:
+    case XEN_DOMCTL_setvcpucontext:
+    case XEN_DOMCTL_getmemlist:
+    case XEN_DOMCTL_getvcpuinfo:
+#ifdef XEN_DOMCTL_get_runstate_info
+    case XEN_DOMCTL_get_runstate_info:
+#endif
+    case XEN_DOMCTL_set_machine_address_size:
+#ifdef XEN_DOMCTL_suppress_spurious_page_faults
+    case XEN_DOMCTL_suppress_spurious_page_faults:
+#endif
+        return 0;
+    default:
+        return -EINVAL;
+    }
+}
+
+static int fake_xen_sysctl(int fd, struct xen_sysctl *sysctl)
+{
+    #define SYSCTLcmd "sysctl"
+    switch (sysctl->cmd) {
+    case XEN_SYSCTL_getdomaininfolist: {
+        xc_domaininfo_t *info; int num, i;
+
+        get_xen_guest_handle(info, sysctl->u.getdomaininfolist.buffer);
+
+        marshall_command(fd, "%s,%d,%d,%d\n", SYSCTLcmd, sysctl->cmd,
+                         sysctl->u.getdomaininfolist.first_domain,
+                         sysctl->u.getdomaininfolist.max_domains);
+        num = unmarshall_int(fd);
+        for (i = 0; i < num; i++) {
+            int uuid[16], j, flags;
+            char **ret;
+            
+            ret = unmarshall_multiple(fd);
+            if (!ret)
+                return -EBADF;
+
+            /* domid,uuid,flags */
+            info->domain = atoi(ret[0]);
+
+            parse_uuid(ret[1], uuid);
+            for (j = 0; j < 16; j++)
+                info->handle[j] = uuid[j] & 0xff;
+
+            flags = atoi(ret[2]);
+            info->flags = 0;
+            if (flags & 0x1) info->flags |= XEN_DOMINF_dying;
+            if (flags & 0x2) info->flags |= XEN_DOMINF_shutdown;
+            if (flags & 0x4) info->flags |= XEN_DOMINF_paused;
+            if (flags & 0x8) info->flags |= XEN_DOMINF_blocked;
+            if (flags & 0x10) info->flags |= XEN_DOMINF_running;
+            if (flags & 0x20) info->flags |= XEN_DOMINF_hvm_guest;
+            info->flags |= ((flags >> 8) & 0xff) << XEN_DOMINF_shutdownshift;
+
+            info->nr_online_vcpus = atoi(ret[3]);
+            info->max_vcpu_id = atoi(ret[4]);
+
+            info->tot_pages = atoi(ret[5]);
+            info->max_pages = atoi(ret[6]);
+            info->shared_info_frame = atoi(ret[7]);
+            info->cpu_time = atoi(ret[8]);
+            info->ssidref = atoi(ret[9]);
+
+            string_split_free(ret);
+            info++;
+
+        }
+        sysctl->u.getdomaininfolist.num_domains = num;
+        return unmarshall_return(fd);
+        }
+    case XEN_SYSCTL_readconsole:
+    case XEN_SYSCTL_debug_keys:
+        return 0;
+    case XEN_SYSCTL_physinfo: {
+        char **ret;
+        int sockets_per_node;
+
+        marshall_command(fd, "%s,%d\n", SYSCTLcmd, sysctl->cmd);
+        ret = unmarshall_multiple(fd);
+        if (!ret) return -EBADF;
+
+        sockets_per_node = atoi(ret[2]);
+
+        sysctl->u.physinfo.threads_per_core = atoi(ret[0]);
+        sysctl->u.physinfo.cores_per_socket = atoi(ret[1]);
+#if XEN_SYSCTL_INTERFACE_VERSION < 6
+        sysctl->u.physinfo.sockets_per_node = sockets_per_node;
+#endif
+        sysctl->u.physinfo.nr_nodes = atoi(ret[3]);
+#if XEN_SYSCTL_INTERFACE_VERSION >= 6
+        sysctl->u.physinfo.nr_cpus =
+            sysctl->u.physinfo.threads_per_core *
+            sysctl->u.physinfo.cores_per_socket *
+            sockets_per_node *
+            sysctl->u.physinfo.nr_nodes;
+#endif
+        sysctl->u.physinfo.cpu_khz = atoi(ret[4]);
+        sysctl->u.physinfo.total_pages = atoi(ret[5]);
+        sysctl->u.physinfo.free_pages = atoi(ret[6]);
+        sysctl->u.physinfo.scrub_pages = 0;
+
+        string_split_free(ret);
+        return unmarshall_return(fd);
+        }
+    case XEN_SYSCTL_getcpuinfo: {
+        xen_sysctl_cpuinfo_t *info;
+        int num, i;
+
+        get_xen_guest_handle(info, sysctl->u.getcpuinfo.info);
+        marshall_command(fd, "%s,%d,%d\n", SYSCTLcmd, sysctl->cmd, 
sysctl->u.getcpuinfo.max_cpus);
+        num = unmarshall_int(fd);
+        for (i = 0; i < num; i++) {
+            info[i].idletime = unmarshall_int64(fd);
+        }
+        return unmarshall_return(fd);
+        }
+    case XEN_SYSCTL_sched_id:
+        return 0;
+    default:
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int fake_xen_eventchn(int fd, unsigned long cmd, unsigned long arg)
+{
+    switch (cmd) {
+    case EVTCHNOP_alloc_unbound:
+    case EVTCHNOP_reset:
+        return 0;
+    default:
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int fake_xen_memoryop(int fd, unsigned long cmd, struct 
xen_memory_reservation *reservation)
+{
+    switch (cmd) {
+    case XENMEM_set_memory_map:
+    case XENMEM_increase_reservation:
+    case XENMEM_decrease_reservation:
+    case XENMEM_populate_physmap:
+        return 0;
+    default:
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int fake_xen_hvmop(int fd, unsigned long cmd, unsigned long arg)
+{
+    switch (cmd) {
+    case HVMOP_get_param:
+        return 0;
+    default:
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int fake_xen_schedop(int fd, unsigned long cmd, sched_remote_shutdown_t 
*arg)
+{
+    switch (cmd) {
+    case SCHEDOP_remote_shutdown:
+        marshall_command(fd, "%s,%d,%d,%d\n", HYPCALLcmd,
+                         1, 
+                         arg->domain_id,
+                         arg->reason);
+        return unmarshall_return(fd);
+    default:
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int fake_xen_versionop(int fd, unsigned long cmd, void * arg)
+{
+    switch (cmd) {
+    case XENVER_extraversion:
+        memset(arg, '\0', sizeof(xen_extraversion_t));
+        memcpy(arg, ".0", 2);
+        return 0;
+    case XENVER_compile_info:
+        memset(arg, '\0', sizeof(xen_compile_info_t));
+        return 0;
+    case XENVER_capabilities:
+        memset(arg, '\0', sizeof(xen_capabilities_info_t));
+        #define CAPA "xen-3.0-x86_64 xen-3.0-x86_32p hvm-3.0-x86_32 
hvm-3.0-x86_32p hvm-3.0-x86_64"
+        memcpy(arg, CAPA, strlen(CAPA));
+        #undef CAPA
+        return 0;
+    case XENVER_changeset:
+        memset(arg, '\0', sizeof(xen_changeset_info_t));
+        return 0;
+    case XENVER_platform_parameters:
+        memset(arg, '\0', sizeof(xen_platform_parameters_t));
+        return 0;
+    case XENVER_version:
+        return (((3 << 16) & 0xffff0000) + (1 & 0xffff)); /* 3.1 */
+    default:
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int xiu_privcmd_hypercall(xc_interface *xch, xc_osdep_handle h, 
privcmd_hypercall_t *hypercall)
+{
+    int fd = (int)h;
+    if (!hypercall) return -EINVAL;
+    switch (hypercall->op) {
+    case __HYPERVISOR_domctl:
+        return fake_xen_domctl(fd, (struct xen_domctl *) 
(intptr_t)hypercall->arg[0]);
+    case __HYPERVISOR_sysctl:
+        return fake_xen_sysctl(fd, (struct xen_sysctl *) 
(intptr_t)hypercall->arg[0]);
+    case __HYPERVISOR_event_channel_op:
+        return fake_xen_eventchn(fd, hypercall->arg[0], hypercall->arg[1]);
+    case __HYPERVISOR_memory_op:
+        return fake_xen_memoryop(fd, hypercall->arg[0], (struct 
xen_memory_reservation *) (intptr_t)hypercall->arg[2]);
+    case __HYPERVISOR_hvm_op:
+        return fake_xen_hvmop(fd, hypercall->arg[0], hypercall->arg[2]);
+    case __HYPERVISOR_sched_op:
+        return fake_xen_schedop(fd, hypercall->arg[0], 
(sched_remote_shutdown_t *) (intptr_t)hypercall->arg[1]);
+    case __HYPERVISOR_xen_version:
+        return fake_xen_versionop(fd, hypercall->arg[0], (void *) 
(intptr_t)hypercall->arg[1]);
+    default:
+        return -EINVAL;
+    }
+}
+
+static void *xiu_privcmd_map_foreign_batch(xc_interface *xch, xc_osdep_handle 
h, uint32_t dom, int prot,
+                                      xen_pfn_t *arr, int num)
+{
+    return mmap(NULL, num << XC_PAGE_SHIFT, prot, MAP_PRIVATE|MAP_ANONYMOUS, 
-1, 0);
+}
+
+static void *xiu_privcmd_map_foreign_bulk(xc_interface *xch, xc_osdep_handle 
h, uint32_t dom, int prot,
+                                     const xen_pfn_t *arr, int *err, unsigned 
int num)
+{
+    return mmap(NULL, (unsigned long)num << XC_PAGE_SHIFT, prot, 
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+}
+
+static void *xiu_privcmd_map_foreign_range(xc_interface *xch, xc_osdep_handle 
h, uint32_t dom, int size, int prot,
+                                      unsigned long mfn)
+{
+    int num = (size + XC_PAGE_SIZE - 1) >> XC_PAGE_SHIFT;
+    return mmap(NULL, num, prot, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+}
+
+static void *xiu_privcmd_map_foreign_ranges(xc_interface *xch, xc_osdep_handle 
h, uint32_t dom, size_t size, int prot,
+                                       size_t chunksize, privcmd_mmap_entry_t 
entries[],
+                                       int nentries)
+{
+    int num_per_entry;
+    int num;
+
+    num_per_entry = chunksize >> XC_PAGE_SHIFT;
+    num = num_per_entry * nentries;
+    return mmap(NULL, num, prot, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+}
+
+static struct xc_osdep_ops xiu_privcmd_ops =
+{
+    .open      = &xiu_privcmd_open,
+    .close     = &xiu_privcmd_close,
+    .u.privcmd   = {
+        .hypercall = &xiu_privcmd_hypercall,
+
+        .map_foreign_batch = &xiu_privcmd_map_foreign_batch,
+        .map_foreign_bulk = &xiu_privcmd_map_foreign_bulk,
+        .map_foreign_range = &xiu_privcmd_map_foreign_range,
+        .map_foreign_ranges = &xiu_privcmd_map_foreign_ranges,
+    }
+};
+
+static xc_osdep_handle xiu_evtchn_open(xc_evtchn *xce)
+{
+       struct sockaddr_un remote;
+       char *s;
+       int fd, len;
+
+       s = getenv("XIU");
+    if (!s)
+    {
+        ERROR(xce, "XIU not found. Set $XIU");
+        return XC_OSDEP_OPEN_ERROR;
+    }
+       snprintf(remote.sun_path, 256, "%s-ev", s);
+       remote.sun_family = AF_UNIX;
+       len = strlen(remote.sun_path) + sizeof(remote.sun_family);
+
+       fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fd == -1)
+    {
+        ERROR(xce, "XIU: Cannot open Unix domain socket");
+        return XC_OSDEP_OPEN_ERROR;
+    }
+
+    if (connect(fd, (struct sockaddr *)&remote, len) != 0)
+    {
+        ERROR(xce, "XIU: Cannot connect to Unix domain socket %s.", 
remote.sun_path);
+        return XC_OSDEP_OPEN_ERROR;
+    }
+
+    return (xc_osdep_handle)fd;
+}
+
+static int xiu_evtchn_close(xc_evtchn *xce, xc_osdep_handle h)
+{
+    int fd = (int)h;
+    return close(fd);
+}
+
+static int xiu_evtchn_fd(xc_evtchn *xce, xc_osdep_handle h)
+{
+    return (int)h;
+}
+
+static int xiu_evtchn_notify(xc_evtchn *xce, xc_osdep_handle h, evtchn_port_t 
port)
+{
+   int fd = (int)h;
+   marshall_command(fd, "ioctl,notify,%d\n", port);
+   return unmarshall_return(fd);
+}
+
+static evtchn_port_or_error_t
+xiu_evtchn_bind_unbound_port(xc_evtchn *xce, xc_osdep_handle h, int domid)
+{
+    return -EINVAL;
+}
+
+static evtchn_port_or_error_t
+xiu_evtchn_bind_interdomain(xc_evtchn *xce, xc_osdep_handle h, int domid,
+                              evtchn_port_t remote_port)
+{
+    int fd = (int)h;
+    marshall_command(fd, "ioctl,bind_interdomain,%d,%d\n", domid, remote_port);
+    return unmarshall_return(fd);
+}
+
+static evtchn_port_or_error_t
+xiu_evtchn_bind_virq(xc_evtchn *xce, xc_osdep_handle h, unsigned int virq)
+{
+    int fd = (int)h;
+    marshall_command(fd, "ioctl,bind_virq,%d\n", virq);
+    return unmarshall_return(fd);
+}
+
+static int xiu_evtchn_unbind(xc_evtchn *xce, xc_osdep_handle h, evtchn_port_t 
port)
+{
+    int fd = (int)h;
+    marshall_command(fd, "ioctl,unbind,%d\n", port);
+    return unmarshall_return(fd);
+}
+
+static evtchn_port_or_error_t xiu_evtchn_pending(xc_evtchn *xce, 
xc_osdep_handle h)
+{
+    int fd = (int)h;
+    evtchn_port_t port;
+
+       marshall_command(fd, "read\n");
+       port = unmarshall_int(fd);
+    if (unmarshall_return(fd) < 0)
+        return port;
+    else
+        return -1;
+}
+
+static int xiu_evtchn_unmask(xc_evtchn *xce, xc_osdep_handle h, evtchn_port_t 
port)
+{
+    int fd = (int)h;
+       marshall_command(fd, "write,%d\n", port);
+       return unmarshall_return(fd);
+}
+
+static struct xc_osdep_ops xiu_evtchn_ops = {
+    .open = &xiu_evtchn_open,
+    .close = &xiu_evtchn_close,
+
+    .u.evtchn = {
+        .fd = &xiu_evtchn_fd,
+        .notify = &xiu_evtchn_notify,
+        .bind_unbound_port = &xiu_evtchn_bind_unbound_port,
+        .bind_interdomain = &xiu_evtchn_bind_interdomain,
+        .bind_virq = &xiu_evtchn_bind_virq,
+        .unbind = &xiu_evtchn_unbind,
+        .pending = &xiu_evtchn_pending,
+        .unmask = &xiu_evtchn_unmask,
+    },
+};
+
+static struct xc_osdep_ops * xiu_osdep_init(xc_interface *xch, enum 
xc_osdep_type type)
+{
+    if (getenv("XIU") == NULL)
+    {
+        ERROR(xch, "XIU not found. Set $XIU");
+        return NULL;
+    }
+
+    switch ( type )
+    {
+    case XC_OSDEP_PRIVCMD:
+        return &xiu_privcmd_ops;
+    case XC_OSDEP_EVTCHN:
+        return &xiu_evtchn_ops;
+    case XC_OSDEP_GNTTAB:
+        ERROR(xch, "GNTTAB interface not supported on this platform");
+        return NULL;
+    default:
+        return NULL;
+    }
+}
+
+xc_osdep_info_t xc_osdep_info = {
+    .name = "Xen In Userspace (XIU) Simulator",
+    .init = &xiu_osdep_init,
+    .fake = 1,
+};
+
+/*
+ * Local variables:
+ * mode: C
+ * c-set-style: "BSD"
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: nil
+ * End:
+ */

_______________________________________________
xen-api mailing list
xen-api@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/mailman/listinfo/xen-api

<Prev in Thread] Current Thread [Next in Thread>