xenforeignmemory_handle *xenforeignmemory_open(xentoollog_logger *logger, unsigned open_flags) { xenforeignmemory_handle *fmem = malloc(sizeof(*fmem)); int rc; if (!fmem) return NULL; fmem->fd = -1; fmem->logger = logger; fmem->logger_tofree = NULL; if (!fmem->logger) { fmem->logger = fmem->logger_tofree = (xentoollog_logger*) xtl_createlogger_stdiostream(stderr, XTL_PROGRESS, 0); if (!fmem->logger) goto err; } rc = osdep_xenforeignmemory_open(fmem); if ( rc < 0 ) goto err; return fmem; err: osdep_xenforeignmemory_close(fmem); xtl_logger_destroy(fmem->logger_tofree); free(fmem); return NULL; }
int vchan_send(struct libxenvchan * chan, char * message, int size){ xentoollog_logger_stdiostream * logger = createDebugLogger(); int res = sendChunkedMessage((xentoollog_logger *)logger, chan, message, size); xtl_logger_destroy((xentoollog_logger *)logger); return res; }
xenevtchn_handle *xenevtchn_open(xentoollog_logger *logger, unsigned open_flags) { xenevtchn_handle *xce = malloc(sizeof(*xce)); int rc; if (!xce) return NULL; xce->fd = -1; xce->logger = logger; xce->logger_tofree = NULL; if (!xce->logger) { xce->logger = xce->logger_tofree = (xentoollog_logger*) xtl_createlogger_stdiostream(stderr, XTL_PROGRESS, 0); if (!xce->logger) goto err; } rc = osdep_evtchn_open(xce); if ( rc < 0 ) goto err; return xce; err: osdep_evtchn_close(xce); xtl_logger_destroy(xce->logger_tofree); free(xce); return NULL; }
char * vchan_receive(struct libxenvchan * chan, int* size){ xentoollog_logger_stdiostream * logger = createDebugLogger(); char * msg=readChunkedMessage((xentoollog_logger *)logger,chan,size); xtl_logger_destroy((xentoollog_logger *)logger); return msg; }
static int xc_interface_close_common(xc_interface *xch) { int rc = 0; if (!xch) return 0; xc__hypercall_buffer_cache_release(xch); xtl_logger_destroy(xch->dombuild_logger_tofree); xtl_logger_destroy(xch->error_handler_tofree); rc = xch->ops->close(xch, xch->ops_handle); if (rc) PERROR("Could not close hypervisor interface"); free(xch); return rc; }
struct xc_interface_core *xc_interface_open(xentoollog_logger *logger, xentoollog_logger *dombuild_logger, unsigned open_flags) { struct xc_interface_core xch_buf = { 0 }, *xch = &xch_buf; xch->flags = open_flags; xch->dombuild_logger_file = 0; xc_clear_last_error(xch); xch->error_handler = logger; xch->error_handler_tofree = 0; xch->dombuild_logger = dombuild_logger; xch->dombuild_logger_tofree = 0; if (!xch->error_handler) { xch->error_handler = xch->error_handler_tofree = (xentoollog_logger*) xtl_createlogger_stdiostream(stderr, XTL_PROGRESS, 0); if (!xch->error_handler) goto err; } xch = malloc(sizeof(*xch)); if (!xch) { xch = &xch_buf; PERROR("Could not allocate new xc_interface struct"); goto err; } *xch = xch_buf; if (open_flags & XC_OPENFLAG_DUMMY) return xch; /* We are done */ xch->xcall = xencall_open(xch->error_handler, open_flags & XC_OPENFLAG_NON_REENTRANT ? XENCALL_OPENFLAG_NON_REENTRANT : 0U); if ( xch->xcall == NULL ) goto err; xch->fmem = xenforeignmemory_open(xch->error_handler, 0); if ( xch->fmem == NULL ) goto err; xch->dmod = xendevicemodel_open(xch->error_handler, 0); if ( xch->dmod == NULL ) goto err; return xch; err: xenforeignmemory_close(xch->fmem); xencall_close(xch->xcall); xtl_logger_destroy(xch->error_handler_tofree); if (xch != &xch_buf) free(xch); return NULL; }
void xen_free_interface(xen_interface_t* xen) { if (xen) { if (xen->xl_ctx) libxl_ctx_free(xen->xl_ctx); if (xen->xl_logger) xtl_logger_destroy(xen->xl_logger); //if (xen->xsh) xs_close(xen->xsh); if (xen->xc) xc_interface_close(xen->xc); free(xen); } }
int xenforeignmemory_close(xenforeignmemory_handle *fmem) { int rc; if ( !fmem ) return 0; rc = osdep_xenforeignmemory_close(fmem); xtl_logger_destroy(fmem->logger_tofree); free(fmem); return rc; }
int xenevtchn_close(xenevtchn_handle *xce) { int rc; if ( !xce ) return 0; rc = osdep_evtchn_close(xce); xtl_logger_destroy(xce->logger_tofree); free(xce); return rc; }
int xc_interface_close(xc_interface *xch) { int rc = 0; if (!xch) return 0; rc = xencall_close(xch->xcall); if (rc) PERROR("Could not close xencall interface"); rc = xenforeignmemory_close(xch->fmem); if (rc) PERROR("Could not close foreign memory interface"); rc = xendevicemodel_close(xch->dmod); if (rc) PERROR("Could not close device model interface"); xtl_logger_destroy(xch->dombuild_logger_tofree); xtl_logger_destroy(xch->error_handler_tofree); free(xch); return rc; }
int xendevicemodel_close(xendevicemodel_handle *dmod) { int rc; if (!dmod) return 0; rc = osdep_xendevicemodel_close(dmod); xencall_close(dmod->xcall); xtl_logger_destroy(dmod->logger_tofree); free(dmod); return rc; }
static void xl_ctx_free(void) { if (ctx) { libxl_ctx_free(ctx); ctx = NULL; } if (logger) { xtl_logger_destroy((xentoollog_logger*)logger); logger = NULL; } if (lockfile) { free(lockfile); lockfile = NULL; } }
static void libxlDriverConfigDispose(void *obj) { libxlDriverConfigPtr cfg = obj; virObjectUnref(cfg->caps); libxl_ctx_free(cfg->ctx); xtl_logger_destroy(cfg->logger); if (cfg->logger_file) VIR_FORCE_FCLOSE(cfg->logger_file); VIR_FREE(cfg->configDir); VIR_FREE(cfg->autostartDir); VIR_FREE(cfg->logDir); VIR_FREE(cfg->stateDir); VIR_FREE(cfg->libDir); VIR_FREE(cfg->saveDir); }
xendevicemodel_handle *xendevicemodel_open(xentoollog_logger *logger, unsigned open_flags) { xendevicemodel_handle *dmod = calloc(1, sizeof(*dmod)); int rc; if (!dmod) return NULL; dmod->flags = open_flags; dmod->logger = logger; dmod->logger_tofree = NULL; if (!dmod->logger) { dmod->logger = dmod->logger_tofree = (xentoollog_logger*) xtl_createlogger_stdiostream(stderr, XTL_PROGRESS, 0); if (!dmod->logger) goto err; } dmod->xcall = xencall_open(dmod->logger, 0); if (!dmod->xcall) goto err; rc = osdep_xendevicemodel_open(dmod); if (rc) goto err; return dmod; err: xtl_logger_destroy(dmod->logger_tofree); xencall_close(dmod->xcall); free(dmod); return NULL; }
int hyperxl_initialize_driver(hyperxl_driver** pdriver, bool verbose) { #ifndef LIBXL_HAVE_BUILDINFO_KERNEL return -1; #else hyperxl_driver *driver; const libxl_version_info* version = NULL; uint32_t mem = 0; xentoollog_level log_level = XTL_INFO; *pdriver = (hyperxl_driver*)malloc(sizeof(hyperxl_driver)); if ( *pdriver == NULL ) { return -1; } driver = *pdriver; if (verbose) { log_level = XTL_DEBUG; } driver->logger = (xentoollog_logger*)xtl_createlogger_hyperxl(log_level, 0); if (driver->logger == NULL) { goto release_driver; } if(libxl_ctx_alloc(&driver->ctx, LIBXL_VERSION, 0, driver->logger)) { goto close_logger; } libxl_childproc_setmode(driver->ctx, &libxl_child_hooks, driver->ctx); version = libxl_get_version_info(driver->ctx); if (version == NULL) { goto free_ctx; } driver->version = version->xen_version_major * 1000000 + version->xen_version_minor * 1000; driver->capabilities = strdup(version->capabilities); if(libxl_get_free_memory(driver->ctx, &mem)) { goto free_ctx; } libxl_event_register_callbacks(driver->ctx, &ev_hooks, driver); return 0; free_ctx: libxl_ctx_free(driver->ctx); close_logger: xtl_logger_destroy(driver->logger); release_driver: free(driver); driver = NULL; return -1; #endif //LIBXL_HAVE_BUILDINFO_KERNEL }
static struct xc_interface_core *xc_interface_open_common(xentoollog_logger *logger, xentoollog_logger *dombuild_logger, unsigned open_flags, enum xc_osdep_type type) { struct xc_interface_core xch_buf, *xch = &xch_buf; xch->type = type; xch->flags = open_flags; xch->dombuild_logger_file = 0; xc_clear_last_error(xch); xch->error_handler = logger; xch->error_handler_tofree = 0; xch->dombuild_logger = dombuild_logger; xch->dombuild_logger_tofree = 0; xch->hypercall_buffer_cache_nr = 0; xch->hypercall_buffer_total_allocations = 0; xch->hypercall_buffer_total_releases = 0; xch->hypercall_buffer_current_allocations = 0; xch->hypercall_buffer_maximum_allocations = 0; xch->hypercall_buffer_cache_hits = 0; xch->hypercall_buffer_cache_misses = 0; xch->hypercall_buffer_cache_toobig = 0; xch->ops_handle = XC_OSDEP_OPEN_ERROR; xch->ops = NULL; if (!xch->error_handler) { xch->error_handler = xch->error_handler_tofree = (xentoollog_logger*) xtl_createlogger_stdiostream(stderr, XTL_PROGRESS, 0); if (!xch->error_handler) goto err; } xch = malloc(sizeof(*xch)); if (!xch) { xch = &xch_buf; PERROR("Could not allocate new xc_interface struct"); goto err; } *xch = xch_buf; if (!(open_flags & XC_OPENFLAG_DUMMY)) { if ( xc_osdep_get_info(xch, &xch->osdep) < 0 ) goto err; xch->ops = xch->osdep.init(xch, type); if ( xch->ops == NULL ) { DPRINTF("OSDEP: interface %d (%s) not supported on this platform", type, xc_osdep_type_name(type)); goto err_put_iface; } xch->ops_handle = xch->ops->open(xch); if (xch->ops_handle == XC_OSDEP_OPEN_ERROR) goto err_put_iface; } return xch; err_put_iface: xc_osdep_put(&xch->osdep); err: xtl_logger_destroy(xch->error_handler_tofree); if (xch != &xch_buf) free(xch); return NULL; }