自学教程：C++ xc_interface_open函数代码示例

static int get_memory_ranges_xen(struct memory_range **range, int *ranges){	int rc, ret = -1;	struct e820entry e820entries[MAX_MEMORY_RANGES];	unsigned int i;#ifdef XENCTRL_HAS_XC_INTERFACE	xc_interface *xc;#else	int xc;#endif#ifdef XENCTRL_HAS_XC_INTERFACE	xc = xc_interface_open(NULL, NULL, 0);	if (!xc) {		fprintf(stderr, "%s: Failed to open Xen control interface/n", __func__);		goto err;	}#else	xc = xc_interface_open();	if (xc == -1) {		fprintf(stderr, "%s: Failed to open Xen control interface/n", __func__);		goto err;	}#endif	rc = xc_get_machine_memory_map(xc, e820entries, MAX_MEMORY_RANGES);	if (rc < 0) {		fprintf(stderr, "%s: xc_get_machine_memory_map: %s/n", __func__, strerror(rc));		goto err;	}	for (i = 0; i < rc; ++i) {		memory_range[i].start = e820entries[i].addr;		memory_range[i].end = e820entries[i].addr + e820entries[i].size;		memory_range[i].type = xen_e820_to_kexec_type(e820entries[i].type);	}	qsort(memory_range, rc, sizeof(struct memory_range), compare_ranges);	*range = memory_range;	*ranges = rc;	ret = 0;err:	xc_interface_close(xc);	return ret;}

static int xen_init(MachineState *ms){    PCMachineState *pcms = PC_MACHINE(ms);    /* Disable ACPI build because Xen handles it */    pcms->acpi_build_enabled = false;    xen_xc = xc_interface_open(0, 0, 0);    if (xen_xc == NULL) {        xen_pv_printf(NULL, 0, "can't open xen interface/n");        return -1;    }    xen_fmem = xenforeignmemory_open(0, 0);    if (xen_fmem == NULL) {        xen_pv_printf(NULL, 0, "can't open xen fmem interface/n");        xc_interface_close(xen_xc);        return -1;    }    qemu_add_vm_change_state_handler(xen_change_state_handler, NULL);    global_state_set_optional();    savevm_skip_configuration();    savevm_skip_section_footers();    return 0;}

/* initialize to view an actively running Xen domain */int xa_init_vm_private    (uint32_t domain_id, xa_instance_t *instance, uint32_t error_mode){    bzero(instance, sizeof(xa_instance_t));#ifdef ENABLE_XEN    int xc_handle;    instance->mode = XA_MODE_XEN;    xa_dbprint("XenAccess Mode Xen/n");    instance->error_mode = error_mode;    xa_dbprint("XenAccess Error Mode = %d/n", instance->error_mode);    /* open handle to the libxc interface */    if ((xc_handle = xc_interface_open()) == -1){        fprintf(stderr, "ERROR: Failed to open libxc interface/n");        return XA_FAILURE;    }    instance->m.xen.xc_handle = xc_handle;    xa_init_common(instance);    instance->m.xen.domain_id = domain_id;    instance->m.xen.live_pfn_to_mfn_table = NULL;    instance->m.xen.nr_pfns = 0;    return helper_init(instance);#else    return XA_FAILURE;#endif /* ENABLE_XEN */}

intxen_setup(void){		xs = xs_daemon_open();	if (xs == NULL) {		dolog(LOG_ERR,		    "Failed to contact xenstore (%s).  Is it running?",		    strerror(errno));		goto out;	}	xc = xc_interface_open();	if (xc == -1) {		dolog(LOG_ERR, "Failed to contact hypervisor (%s)",		    strerror(errno));		goto out;	}	if (!xs_watch(xs, DOMAIN_PATH, "backend")) {		dolog(LOG_ERR, "xenstore watch on backend fails.");		goto out;	}	return 0; out:	if (xs)		xs_daemon_close(xs);	if (xc != -1)		xc_interface_close(xc);	return -1;}

bool xen_setup(void){		xs = xs_daemon_open();	if (xs == NULL) {		dolog(LOG_ERR,		      "Failed to contact xenstore (%m).  Is it running?");		goto out;	}	xc = xc_interface_open();	if (xc == -1) {		dolog(LOG_ERR, "Failed to contact hypervisor (%m)");		goto out;	}		if (!xs_watch(xs, "@introduceDomain", "domlist")) {		dolog(LOG_ERR, "xenstore watch on @introduceDomain fails.");		goto out;	}		if (!xs_watch(xs, "@releaseDomain", "domlist")) {		dolog(LOG_ERR, "xenstore watch on @releaseDomain fails.");		goto out;	}	return true; out:	if (xs)		xs_daemon_close(xs);	if (xc != -1)		xc_interface_close(xc);	return false;}

XenDomainWatcher::XenDomainWatcher( LogHelper *logHelper )    : xsh_( NULL ), xci_( NULL ), introduceToken_( "introduce" ), releaseToken_( "release" ), logHelper_( logHelper ){	xsh_ = xs_open( 0 );	if ( !xsh_ )		throw Exception( "xs_open() failed" );	if ( !xs_watch( xsh_, "@introduceDomain", introduceToken_.c_str() ) ) {		xs_close( xsh_ );		throw Exception( "xs_watch() failed" );	}	if ( !xs_watch( xsh_, "@releaseDomain", releaseToken_.c_str() ) ) {		xs_unwatch( xsh_, "@introduceDomain", introduceToken_.c_str() );		xs_close( xsh_ );		throw Exception( "xs_watch() failed" );	}	xci_ = xc_interface_open( NULL, NULL, 0 );	if ( !xci_ ) {		xs_unwatch( xsh_, "@introduceDomain", introduceToken_.c_str() );		xs_unwatch( xsh_, "@releaseDomain", releaseToken_.c_str() );		xs_close( xsh_ );		throw Exception( "xc_interface_init() failed" );	}}

int main(int argc, char **argv){	int err = 0;	xc_interface *xch;	int value;	if (argc != 3)		usage(argv);	value = str2bool(argv[2]);	xch = xc_interface_open(0,0,0);	if ( !xch )	{		fprintf(stderr, "Unable to create interface to xenctrl: %s/n",				strerror(errno));		err = 1;		goto done;	}	err = xc_flask_setbool(xch, argv[1], value, 1);	if (err) {		fprintf(stderr, "xc_flask_setbool: Unable to set boolean %s=%s: %s (%d)",			argv[1], argv[2], strerror(errno), err);		err = 2;		goto done;	} done:	if ( xch )		xc_interface_close(xch);	return err;}

libvchan_t *libvchan_server_init(int domain, int port, size_t read_min, size_t write_min) {    char xs_path[255];    libvchan_t *ctrl;    ctrl = malloc(sizeof(*ctrl));    if (!ctrl)        return NULL;    snprintf(xs_path, sizeof(xs_path), "data/vchan/%d/%d", domain, port);    ctrl->xenvchan = libxenvchan_server_init(NULL, domain, xs_path, read_min, write_min);    if (!ctrl->xenvchan) {        free(ctrl);        return NULL;    }    ctrl->xs_path = strdup(xs_path);    ctrl->xenvchan->blocking = 1;    ctrl->remote_domain = domain;    ctrl->xc_handle = xc_interface_open(NULL, NULL, 0);    if (!ctrl->xc_handle) {        /* error already logged by xc_interface_open */        libxenvchan_close(ctrl->xenvchan);        free(ctrl);        return NULL;    }    return ctrl;}

  static void openXenHandles(HSP *sp)  {    // need to do this while we still have root privileges    if(sp->xc_handle == 0) {      sp->xc_handle = xc_interface_open();      if(sp->xc_handle <= 0) {        myLog(LOG_ERR, "xc_interface_open() failed : %s", strerror(errno));      }      else {        sp->xs_handle = xs_daemon_open_readonly();        if(sp->xs_handle == NULL) {          myLog(LOG_ERR, "xs_daemon_open_readonly() failed : %s", strerror(errno));        }        // get the page size [ref xenstat.c]#if defined(PAGESIZE)        sp->page_size = PAGESIZE;#elif defined(PAGE_SIZE)        sp->page_size = PAGE_SIZE;#else        sp->page_size = sysconf(_SC_PAGE_SIZE);        if(pgsiz < 0) {          myLog(LOG_ERR, "Failed to retrieve page size : %s", strerror(errno));          abort();        }#endif      }    }  }

static PyObject *pyflask_sid_to_context(PyObject *self, PyObject *args,                                                                 PyObject *kwds){    int xc_handle;    uint32_t sid;    char ctx[CTX_LEN];    uint32_t ctx_len = CTX_LEN;    int ret;    static char *kwd_list[] = { "sid", NULL };    if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i", kwd_list,                                      &sid) )        return NULL;    xc_handle = xc_interface_open();    if (xc_handle < 0) {        errno = xc_handle;        return PyErr_SetFromErrno(xc_error_obj);    }        ret = flask_sid_to_context(xc_handle, sid, ctx, ctx_len);        xc_interface_close(xc_handle);        if ( ret != 0 ) {        errno = -ret;        return PyErr_SetFromErrno(xc_error_obj);    }    return Py_BuildValue("s", ctx, ctx_len);}

/** * map_tbufs - memory map Xen trace buffers into user space * @tbufs_mfn: mfn of the trace buffers * @num:       number of trace buffers to map * @size:      size of each trace buffer * * Maps the Xen trace buffers them into process address space. */struct t_buf *map_tbufs(unsigned long tbufs_mfn, unsigned int num,                        unsigned long size){    int xc_handle;    struct t_buf *tbufs_mapped;    xc_handle = xc_interface_open();    if ( xc_handle < 0 )     {        exit(EXIT_FAILURE);    }    tbufs_mapped = xc_map_foreign_range(xc_handle, DOMID_XEN,                                        size * num, PROT_READ | PROT_WRITE,                                        tbufs_mfn);    xc_interface_close(xc_handle);    if ( tbufs_mapped == 0 )     {        PERROR("Failed to mmap trace buffers");        exit(EXIT_FAILURE);    }    return tbufs_mapped;}

int main(int argc, char **argv){    int opt;    while ((opt = getopt(argc, argv, "h")) != -1) {        switch (opt) {        case 'h':            usage(0);            break;        default:            usage(1);        }    }    argv += optind;    argc -= optind;    if (argc <= 0)        usage(1);    xch = xc_interface_open(NULL, NULL, 0);    if (!xch)        err(1, "opening xc interface");    if (strcmp(argv[0], "reset") == 0)        gcov_reset();    else if (strcmp(argv[0], "read") == 0)        gcov_read(argc > 1 ? argv[1] : "-");    else        usage(1);    xc_interface_close(xch);    return 0;}

/* generic shared function */static void *__getssid(int domid, uint32_t *buflen){    struct acm_getssid getssid;    int xc_handle;#define SSID_BUFFER_SIZE    4096    void *buf = NULL;    if ((xc_handle = xc_interface_open()) < 0) {        goto out1;    }    if ((buf = malloc(SSID_BUFFER_SIZE)) == NULL) {        PERROR("acm.policytype: Could not allocate ssid buffer!/n");        goto out2;    }    memset(buf, 0, SSID_BUFFER_SIZE);    set_xen_guest_handle(getssid.ssidbuf, buf);    getssid.ssidbuf_size = SSID_BUFFER_SIZE;    getssid.get_ssid_by = ACM_GETBY_domainid;    getssid.id.domainid = domid;    if (xc_acm_op(xc_handle, ACMOP_getssid, &getssid, sizeof(getssid)) < 0) {        if (errno == EACCES)            PERROR("ACM operation failed.");        free(buf);        buf = NULL;        goto out2;    } else {        *buflen = SSID_BUFFER_SIZE;        goto out2;    }out2:    xc_interface_close(xc_handle);out1:    return buf;}

static PyObject *getpolicy(PyObject *self, PyObject *args){    struct acm_getpolicy getpolicy;    int xc_handle, rc;    uint8_t pull_buffer[8192];    PyObject *result;    uint32_t len = sizeof(pull_buffer);    memset(&getpolicy, 0x0, sizeof(getpolicy));    set_xen_guest_handle(getpolicy.pullcache, pull_buffer);    getpolicy.pullcache_size = sizeof(pull_buffer);    if ((xc_handle = xc_interface_open()) <= 0) {        PyErr_SetString(PyExc_IOError, ctrlif_op);        return NULL;    }    rc = xc_acm_op(xc_handle, ACMOP_getpolicy, &getpolicy, sizeof(getpolicy));    xc_interface_close(xc_handle);    if (rc == 0) {        struct acm_policy_buffer *header =            (struct acm_policy_buffer *)pull_buffer;        if (ntohl(header->len) < sizeof(pull_buffer))            len = ntohl(header->len);    } else {        len = 0;    }    result = Py_BuildValue("is#", rc, pull_buffer, len);    return result;}

bool xen_init_interface(xen_interface_t **xen) {    *xen = g_malloc0(sizeof(xen_interface_t));    /* We create an xc interface to test connection to it */    (*xen)->xc = xc_interface_open(0, 0, 0);    if ((*xen)->xc == NULL) {        fprintf(stderr, "xc_interface_open() failed!/n");        goto err;    }    /* We don't need this at the moment, but just in case */    //xen->xsh=xs_open(XS_OPEN_READONLY);    (*xen)->xl_logger = (xentoollog_logger *) xtl_createlogger_stdiostream(            stderr, XTL_PROGRESS, 0);    if (!(*xen)->xl_logger)    {        goto err;    }    if (libxl_ctx_alloc(&(*xen)->xl_ctx, LIBXL_VERSION, 0,                        (*xen)->xl_logger)) {        fprintf(stderr, "libxl_ctx_alloc() failed!/n");        goto err;    }    return 1;err:    xen_free_interface(*xen);    *xen = NULL;    return 0;}

static int __hypercall_perform(unsigned long cmd, unsigned long *arr){	int ret;	xc_interface *xch = xc_interface_open(0, 0, 0);	DECLARE_HYPERCALL;	if (xch == NULL)		goto err;	hypercall.op = __HYPERVISOR_xen_version;	hypercall.arg[0] = cmd;	hypercall.arg[1] = (unsigned long) arr;	ret = do_xen_hypercall(xch, &hypercall);	xc_interface_close(xch);	if (ret != 0)		goto err; out:	return ret; err:	ret = -1;	goto out;}

CAMLprim value stub_xenguest_init(){	xc_interface *xch;	xch = xc_interface_open(NULL, NULL, 0);	if (xch == NULL)		failwith_oss_xc(NULL, "xc_interface_open");	return (value)xch;}

int main(int argc, char *argv[]){    int i, ret = 0;    xc_physinfo_t physinfo = { 0 };    int nr_matches = 0;    int matches_main_options[ARRAY_SIZE(main_options)];    if ( argc < 2 )    {        show_help();        return 0;    }    xc_handle = xc_interface_open(0,0,0);    if ( !xc_handle )    {        fprintf(stderr, "failed to get the handler/n");        return EIO;    }    ret = xc_physinfo(xc_handle, &physinfo);    if ( ret )    {        ret = errno;        fprintf(stderr, "failed to get processor information (%d - %s)/n",                ret, strerror(ret));        xc_interface_close(xc_handle);        return ret;    }    max_cpu_nr = physinfo.nr_cpus;    /* calculate how many options match with user's input */    for ( i = 0; i < ARRAY_SIZE(main_options); i++ )        if ( !strncmp(main_options[i].name, argv[1], strlen(argv[1])) )            matches_main_options[nr_matches++] = i;    if ( nr_matches > 1 )    {        fprintf(stderr, "Ambiguous options: ");        for ( i = 0; i < nr_matches; i++ )            fprintf(stderr, " %s", main_options[matches_main_options[i]].name);        fprintf(stderr, "/n");        ret = EINVAL;    }    else if ( nr_matches == 1 )        /* dispatch to the corresponding function handler */        main_options[matches_main_options[0]].function(argc - 2, argv + 2);    else    {        show_help();        ret = EINVAL;    }    xc_interface_close(xc_handle);    return ret;}

int main(int argc, char **argv){    xc_interface *xch;    int domid, port, rc;    xc_evtchn_status_t status;    domid = (argc > 1) ? strtol(argv[1], NULL, 10) : 0;    xch = xc_interface_open(0,0,0);    if ( !xch )        errx(1, "failed to open control interface");    for ( port = 0; ; port++ )    {        status.dom = domid;        status.port = port;        rc = xc_evtchn_status(xch, &status);        if ( rc < 0 )            break;        if ( status.status == EVTCHNSTAT_closed )            continue;        printf("%4d: VCPU %u: ", port, status.vcpu);        switch ( status.status )        {        case EVTCHNSTAT_unbound:            printf("Interdomain (Waiting connection) - Remote Domain %u",                   status.u.unbound.dom);            break;        case EVTCHNSTAT_interdomain:            printf("Interdomain (Connected) - Remote Domain %u, Port %u",                   status.u.interdomain.dom, status.u.interdomain.port);            break;        case EVTCHNSTAT_pirq:            printf("Physical IRQ %u", status.u.pirq);            break;        case EVTCHNSTAT_virq:            printf("Virtual IRQ %u", status.u.virq);            break;        case EVTCHNSTAT_ipi:            printf("IPI");            break;        default:            printf("Unknown");            break;        }        printf("/n");    }    xc_interface_close(xch);    return 0;}

// give index of this domain in the qos data arrayint indexof(int domid){  int idx;  xc_dominfo_t dominfo[NDOMAINS];  int xc_handle, ndomains;  extern void qos_kill_thread(int domid);    if (domid < 0) {	// shouldn't happen    printf("bad domain id: %d/r/n", domid);    return 0;  }  for (idx=0; idx<NDOMAINS; idx++)    if ( (new_qos->domain_info[idx].id == domid) && new_qos->domain_info[idx].in_use)      return idx;  // not found, make a new entry  for (idx=0; idx<NDOMAINS; idx++)    if (new_qos->domain_info[idx].in_use == 0) {      global_init_domain(domid, idx);      return idx;    }  // call domaininfo hypercall to try and garbage collect unused entries  xc_handle = xc_interface_open();  ndomains = xc_domain_getinfo(xc_handle, 0, NDOMAINS, dominfo);  xc_interface_close(xc_handle);  // for each domain in our data, look for it in the system dominfo structure  // and purge the domain's data from our state if it does not exist in the  // dominfo structure  for (idx=0; idx<NDOMAINS; idx++) {    int domid = new_qos->domain_info[idx].id;    int jdx;        for (jdx=0; jdx<ndomains; jdx++) {      if (dominfo[jdx].domid == domid)	break;    }    if (jdx == ndomains)        // we didn't find domid in the dominfo struct      if (domid != IDLE_DOMAIN_ID) // exception for idle domain, which is not	                           // contained in dominfo	qos_kill_thread(domid);	// purge our stale data  }    // look again for a free slot  for (idx=0; idx<NDOMAINS; idx++)    if (new_qos->domain_info[idx].in_use == 0) {      global_init_domain(domid, idx);      return idx;    }  // still no space found, so bail  fprintf(stderr, "out of space in domain table, increase NDOMAINS/r/n");  exit(2);}

/* retrieve access decision based on domain ids or ssidrefs */static PyObject *getdecision(PyObject * self, PyObject * args){    char *arg1_name, *arg1, *arg2_name, *arg2, *decision = NULL;    struct acm_getdecision getdecision;    int xc_handle, rc;    uint32_t hooktype;    if (!PyArg_ParseTuple(args, "ssssi", &arg1_name,                          &arg1, &arg2_name, &arg2, &hooktype)) {        return NULL;    }    if ((xc_handle = xc_interface_open()) <= 0) {        PERROR("Could not open xen privcmd device!/n");        return NULL;    }    if ((strcmp(arg1_name, "domid") && strcmp(arg1_name, "ssidref")) ||            (strcmp(arg2_name, "domid") && strcmp(arg2_name, "ssidref")))        return NULL;    getdecision.hook = hooktype;    if (!strcmp(arg1_name, "domid")) {        getdecision.get_decision_by1 = ACM_GETBY_domainid;        getdecision.id1.domainid = atoi(arg1);    } else {        getdecision.get_decision_by1 = ACM_GETBY_ssidref;        getdecision.id1.ssidref = atol(arg1);    }    if (!strcmp(arg2_name, "domid")) {        getdecision.get_decision_by2 = ACM_GETBY_domainid;        getdecision.id2.domainid = atoi(arg2);    } else {        getdecision.get_decision_by2 = ACM_GETBY_ssidref;        getdecision.id2.ssidref = atol(arg2);    }    rc = xc_acm_op(xc_handle, ACMOP_getdecision,                   &getdecision, sizeof(getdecision));    xc_interface_close(xc_handle);    if (rc < 0) {        if (errno == EACCES)            PERROR("ACM operation failed.");        return NULL;    }    if (getdecision.acm_decision == ACM_ACCESS_PERMITTED)        decision = "PERMITTED";    else if (getdecision.acm_decision == ACM_ACCESS_DENIED)        decision = "DENIED";    return Py_BuildValue("s", decision);}

CAMLprim value stub_xenguest_init(){    xc_interface *xch;    openlog("xenguest", LOG_NDELAY, LOG_DAEMON);    xch = xc_interface_open(NULL, NULL, 0);    if (xch == NULL)        failwith_oss_xc(NULL, "xc_interface_open");    return (value)xch;}

void xen_kexec_exec(void){	xc_interface *xch;		xch = xc_interface_open(NULL, NULL, 0);	if (!xch)		return;	xc_kexec_exec(xch, KEXEC_TYPE_DEFAULT);	xc_interface_close(xch);}

static void startup(const char *op) {    logger = (xentoollog_logger*)createlogger_tellparent();    if (!logger) {        fprintf(stderr, "%s: cannot initialise logger/n", program);        exit(-1);    }    xtl_log(logger,XTL_DEBUG,0,program,"starting %s",op);    xch = xc_interface_open(logger,logger,0);    if (!xch) fail(errno,"xc_interface_open failed");}

static int xencpu_init (void){    xc_handle = xc_interface_open(XC_INTERFACE_INIT_ARGS);    if (!xc_handle)    {        ERROR ("xencpu: xc_interface_open() failed");        return (-1);    }    xc_physinfo_t *physinfo;    physinfo = calloc(1, sizeof(xc_physinfo_t));    if (physinfo == NULL)    {        ERROR ("xencpu plugin: calloc() for physinfo failed.");        xc_interface_close(xc_handle);        return (ENOMEM);    }    if (xc_physinfo(xc_handle, physinfo) < 0)    {        ERROR ("xencpu plugin: xc_physinfo() failed");        xc_interface_close(xc_handle);        free(physinfo);        return (-1);    }    num_cpus = physinfo->nr_cpus;    free(physinfo);    INFO ("xencpu plugin: Found %"PRIu32" processors.", num_cpus);    cpu_info = calloc(num_cpus, sizeof(xc_cpuinfo_t));    if (cpu_info == NULL)    {        ERROR ("xencpu plugin: calloc() for num_cpus failed.");        xc_interface_close(xc_handle);        return (ENOMEM);    }    cpu_states = calloc (num_cpus, sizeof (value_to_rate_state_t));    if (cpu_states == NULL)    {        ERROR ("xencpu plugin: calloc() for cpu_states failed.");        xc_interface_close(xc_handle);        free(cpu_info);        return (ENOMEM);    }    return (0);} /* static int xencpu_init */

static PyObject *chgpolicy(PyObject *self, PyObject *args){    struct acm_change_policy chgpolicy;    int xc_handle, rc;    char *bin_pol = NULL, *del_arr = NULL, *chg_arr = NULL;    int bin_pol_len = 0, del_arr_len = 0, chg_arr_len = 0;    uint errarray_mbrs = 20 * 2;    uint32_t error_array[errarray_mbrs];    PyObject *result;    uint len;    memset(&chgpolicy, 0x0, sizeof(chgpolicy));    if (!PyArg_ParseTuple(args, "s#s#s#" ,&bin_pol, &bin_pol_len,                          &del_arr, &del_arr_len,                          &chg_arr, &chg_arr_len)) {        PyErr_SetString(PyExc_TypeError, bad_arg);        return NULL;    }    chgpolicy.policy_pushcache_size = bin_pol_len;    chgpolicy.delarray_size = del_arr_len;    chgpolicy.chgarray_size = chg_arr_len;    chgpolicy.errarray_size = sizeof(error_array);    set_xen_guest_handle(chgpolicy.policy_pushcache, bin_pol);    set_xen_guest_handle(chgpolicy.del_array, del_arr);    set_xen_guest_handle(chgpolicy.chg_array, chg_arr);    set_xen_guest_handle(chgpolicy.err_array, error_array);    if ((xc_handle = xc_interface_open()) <= 0) {        PyErr_SetString(PyExc_IOError, ctrlif_op);        return NULL;    }    rc = xc_acm_op(xc_handle, ACMOP_chgpolicy, &chgpolicy, sizeof(chgpolicy));    xc_interface_close(xc_handle);    /* only pass the filled error codes */    for (len = 0; (len + 1) < errarray_mbrs; len += 2) {        if (error_array[len] == 0) {            len *= sizeof(error_array[0]);            break;        }    }    result = Py_BuildValue("is#", rc, error_array, len);    return result;}

int main(int argc, char * argv[]){    struct xen_sysctl sysctl;    int ret;    xc_interface *xc_handle = xc_interface_open(0,0,0);    sysctl.cmd = XEN_SYSCTL_tbuf_op;    sysctl.interface_version = XEN_SYSCTL_INTERFACE_VERSION;    sysctl.u.tbuf_op.cmd  = XEN_SYSCTL_TBUFOP_get_info;    ret = xc_sysctl(xc_handle, &sysctl);    if ( ret != 0 )    {        perror("Failure to get event mask from Xen");        exit(1);    }    else    {        printf("Current event mask: 0x%.8x/n", sysctl.u.tbuf_op.evt_mask);    }    sysctl.cmd = XEN_SYSCTL_tbuf_op;    sysctl.interface_version = XEN_SYSCTL_INTERFACE_VERSION;    sysctl.u.tbuf_op.cmd  = XEN_SYSCTL_TBUFOP_set_evt_mask;    sysctl.u.tbuf_op.evt_mask = XENMON;    ret = xc_sysctl(xc_handle, &sysctl);    printf("Setting mask to 0x%.8x/n", sysctl.u.tbuf_op.evt_mask);    if ( ret != 0 )    {        perror("Failure to get scheduler ID from Xen");        exit(1);    }    sysctl.cmd = XEN_SYSCTL_tbuf_op;    sysctl.interface_version = XEN_SYSCTL_INTERFACE_VERSION;    sysctl.u.tbuf_op.cmd  = XEN_SYSCTL_TBUFOP_get_info;    ret = xc_sysctl(xc_handle, &sysctl);    if ( ret != 0 )    {        perror("Failure to get event mask from Xen");        exit(1);    }    else    {        printf("Current event mask: 0x%.8x/n", sysctl.u.tbuf_op.evt_mask);    }    xc_interface_close(xc_handle);    return 0;}