void libxenvchan_close(struct libxenvchan *ctrl)
{
if (!ctrl)
return;
if (ctrl->read.order >= PAGE_SHIFT)
munmap(ctrl->read.buffer, 1 << ctrl->read.order);
if (ctrl->write.order >= PAGE_SHIFT)
munmap(ctrl->write.buffer, 1 << ctrl->write.order);
if (ctrl->ring) {
if (ctrl->is_server) {
ctrl->ring->srv_live = 0;
xc_gntshr_munmap(ctrl->gntshr, ctrl->ring, PAGE_SIZE);
} else {
ctrl->ring->cli_live = 0;
xc_gnttab_munmap(ctrl->gnttab, ctrl->ring, PAGE_SIZE);
}
}
if (ctrl->event) {
if (ctrl->event_port >= 0 && ctrl->ring)
xc_evtchn_notify(ctrl->event, ctrl->event_port);
xc_evtchn_close(ctrl->event);
}
if (ctrl->is_server) {
if (ctrl->gntshr)
xc_gntshr_close(ctrl->gntshr);
} else {
if (ctrl->gnttab)
xc_gnttab_close(ctrl->gnttab);
}
free(ctrl);
}
/**
* TODO releases a pool?
*/
static void
tapdisk_xenio_ctx_close(struct td_xenio_ctx * const ctx)
{
if (!ctx)
return;
if (ctx->ring_event >= 0) {
tapdisk_server_unregister_event(ctx->ring_event);
ctx->ring_event = -1;
}
if (ctx->xce_handle) {
xc_evtchn_close(ctx->xce_handle);
ctx->xce_handle = NULL;
}
if (ctx->xcg_handle) {
xc_gnttab_close(ctx->xcg_handle);
ctx->xcg_handle = NULL;
}
if (ctx->gntdev_fd != -1) {
close(ctx->gntdev_fd);
ctx->gntdev_fd = -1;
}
list_del(&ctx->entry);
free(ctx);
}
static int init_evt_cli(struct libxenvchan *ctrl, int domain, xentoollog_logger *logger)
{
evtchn_port_or_error_t port;
ctrl->event = xc_evtchn_open(logger, 0);
if (!ctrl->event)
return -1;
port = xc_evtchn_bind_interdomain(ctrl->event,
domain, ctrl->event_port);
if (port < 0)
goto fail;
ctrl->event_port = port;
if (xc_evtchn_unmask(ctrl->event, ctrl->event_port))
goto fail;
return 0;
fail:
if (port >= 0)
xc_evtchn_unbind(ctrl->event, port);
xc_evtchn_close(ctrl->event);
ctrl->event = NULL;
return -1;
}
void checkpoint_close(checkpoint_state* s)
{
if (s->timer)
delete_suspend_timer(s);
if (s->suspend_thr)
stop_suspend_thread(s);
release_shutdown_watch(s);
release_suspend_evtchn(s);
if (s->xch >= 0) {
xc_interface_close(s->xch);
s->xch = -1;
}
if (s->xce >= 0) {
xc_evtchn_close(s->xce);
s->xce = -1;
}
if (s->xsh) {
xs_daemon_close(s->xsh);
s->xsh = NULL;
}
s->domid = 0;
s->fd = -1;
}
void closeIVCLibrary(libIVC_t *iface)
{
xc_evtchn_close(iface->ec);
xs_close(iface->xs);
xc_interface_close(iface->xc);
xc_gnttab_close(iface->gt);
#ifdef HAVE_XENSTORE_H
if(iface->gs) xc_gntshr_close(iface->gs);
#endif
free(iface);
}
static int suspend_evtchn_release(void)
{
if (si.suspend_evtchn >= 0) {
xc_evtchn_unbind(si.xce, si.suspend_evtchn);
si.suspend_evtchn = -1;
}
if (si.xce >= 0) {
xc_evtchn_close(si.xce);
si.xce = -1;
}
return 0;
}
/* Remove the backend area in xenbus since the framebuffer really is
going away. */
void xenfb_shutdown(struct xenfb *xenfb)
{
fprintf(stderr, "FB: Shutting down backend\n");
xs_rm(xenfb->xsh, XBT_NULL, xenfb->fb.nodename);
xs_rm(xenfb->xsh, XBT_NULL, xenfb->kbd.nodename);
xenfb_detach_dom(xenfb);
if (xenfb->xc >= 0)
xc_interface_close(xenfb->xc);
if (xenfb->evt_xch >= 0)
xc_evtchn_close(xenfb->evt_xch);
if (xenfb->xsh)
xs_daemon_close(xenfb->xsh);
free(xenfb);
}
static void xen_cleanup() {
char keybuf[64];
/*XXX hardcoded*/
munmap((void*)gref.index, 4096);
set_state(XenbusStateClosing);
/* send one last event to unblock the backend */
xc_evtchn_notify(xce, xen_evtchn_port);
/* close xen interfaces */
xc_evtchn_close(xce);
xc_interface_close(xch);
/* delete xenstore keys */
publish_param_int("state", XenbusStateClosed);
snprintf(keybuf, sizeof(keybuf), "device/audio/%d", device_id);
xs_rm(xsh, 0, keybuf);
xs_daemon_close(xsh);
}
CAMLprim value stub_eventchn_close(value xce)
{
return Val_int(xc_evtchn_close(_H(xce)));
}
static void *handle_mount(void *data)
{
int more, notify;
struct fs_mount *mount = (struct fs_mount *)data;
printf("Starting a thread for mount: %d\n", mount->mount_id);
allocate_request_array(mount);
for(;;)
{
int nr_consumed=0;
RING_IDX cons, rp;
struct fsif_request *req;
handle_aio_events(mount);
moretodo:
rp = mount->ring.sring->req_prod;
xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
while ((cons = mount->ring.req_cons) != rp)
{
int i;
struct fs_op *op;
printf("Got a request at %d (of %d)\n",
cons, RING_SIZE(&mount->ring));
req = RING_GET_REQUEST(&mount->ring, cons);
printf("Request type=%d\n", req->type);
for(i=0;;i++)
{
op = fsops[i];
if(op == NULL)
{
/* We've reached the end of the array, no appropirate
* handler found. Warn, ignore and continue. */
printf("WARN: Unknown request type: %d\n", req->type);
mount->ring.req_cons++;
break;
}
if(op->type == req->type)
{
/* There needs to be a dispatch handler */
assert(op->dispatch_handler != NULL);
op->dispatch_handler(mount, req);
break;
}
}
nr_consumed++;
}
printf("Backend consumed: %d requests\n", nr_consumed);
RING_FINAL_CHECK_FOR_REQUESTS(&mount->ring, more);
if(more) goto moretodo;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&mount->ring, notify);
printf("Pushed responces and notify=%d\n", notify);
if(notify)
xc_evtchn_notify(mount->evth, mount->local_evtchn);
}
printf("Destroying thread for mount: %d\n", mount->mount_id);
xc_gnttab_munmap(mount->gnth, mount->ring.sring, 1);
xc_gnttab_close(mount->gnth);
xc_evtchn_unbind(mount->evth, mount->local_evtchn);
xc_evtchn_close(mount->evth);
free(mount->frontend);
pthread_exit(NULL);
}
static int hp_mem_offline_func(int argc, char *argv[])
{
uint32_t status, domid;
int ret;
unsigned long mfn;
if (argc != 1)
{
show_help();
return -1;
}
sscanf(argv[0], "%lx", &mfn);
printf("Prepare to offline MEMORY mfn %lx\n", mfn);
ret = xc_mark_page_offline(xch, mfn, mfn, &status);
if (ret < 0) {
fprintf(stderr, "Offlining page mfn %lx failed, error %x\n", mfn, ret);
if (status & (PG_OFFLINE_XENPAGE | PG_OFFLINE_FAILED))
fprintf(stderr, "XEN_PAGE is not permitted be offlined\n");
else if (status & (PG_OFFLINE_FAILED | PG_OFFLINE_NOT_CONV_RAM))
fprintf(stderr, "RESERVED RAM is not permitted to be offlined\n");
}
else
{
switch(status & PG_OFFLINE_STATUS_MASK)
{
case PG_OFFLINE_OFFLINED:
{
printf("Memory mfn %lx offlined successfully, current state is"
" [PG_OFFLINE_OFFLINED]\n", mfn);
if (status & PG_OFFLINE_BROKEN)
printf("And this offlined PAGE is already marked broken"
" before!\n");
break;
}
case PG_OFFLINE_FAILED:
{
fprintf(stderr, "Memory mfn %lx offline failed\n", mfn);
if ( status & PG_OFFLINE_ANONYMOUS)
fprintf(stderr, "the memory is an anonymous page!\n");
ret = -1;
break;
}
case PG_OFFLINE_PENDING:
{
if (status & PG_OFFLINE_XENPAGE) {
ret = -1;
fprintf(stderr, "Memory mfn %lx offlined succssefully,"
"this page is xen page, current state is"
" [PG_OFFLINE_PENDING, PG_OFFLINE_XENPAGE]\n", mfn);
}
else if (status & PG_OFFLINE_OWNED)
{
int result, suspend_evtchn = -1, suspend_lockfd = -1;
xc_evtchn *xce;
xce = xc_evtchn_open(NULL, 0);
if (xce == NULL)
{
fprintf(stderr, "When exchange page, fail"
" to open evtchn\n");
return -1;
}
domid = status >> PG_OFFLINE_OWNER_SHIFT;
if (suspend_guest(xch, xce, domid,
&suspend_evtchn, &suspend_lockfd))
{
fprintf(stderr, "Failed to suspend guest %d for"
" mfn %lx\n", domid, mfn);
xc_evtchn_close(xce);
return -1;
}
result = xc_exchange_page(xch, domid, mfn);
/* Exchange page successfully */
if (result == 0)
printf("Memory mfn %lx offlined successfully, this "
"page is DOM%d page and being swapped "
"successfully, current state is "
"[PG_OFFLINE_OFFLINED, PG_OFFLINE_OWNED]\n",
mfn, domid);
else {
ret = -1;
fprintf(stderr, "Memory mfn %lx offlined successfully"
" , this page is DOM%d page yet failed to be "
"exchanged. current state is "
"[PG_OFFLINE_PENDING, PG_OFFLINE_OWNED]\n",
mfn, domid);
}
xc_domain_resume(xch, domid, 1);
xc_suspend_evtchn_release(xch, xce, domid,
suspend_evtchn, &suspend_lockfd);
xc_evtchn_close(xce);
}
break;
}
}//end of switch
}//end of if
