static void *framebuffer_grant_test(uint32_t domid, uint32_t num_pages)
{
xc_gnttab *xcg;
int i = 0;
uint32_t refs[2560];
void *p;
memset(refs, 0, 2560*sizeof(uint32_t));
xcg = xc_gnttab_open(NULL, 0);
if ( !xcg )
{
printf("Failed to open grant device, dying.\n");
return;
}
for (i = 0; i < num_pages; i++) {
refs[i] = i;
}
p = xc_gnttab_map_domain_grant_refs(xcg,
num_pages,
domid,
refs,
PROT_READ);
if ( p ) {
printf("Mapped %d refs, ptr: %p\n", i, p);
} else {
printf("Failed to map at ref: %d\n", 0);
abort();
}
xc_gnttab_close(xcg);
return p;
}
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);
}
CAMLprim value stub_gnttab_interface_close(value xgh)
{
CAMLparam1(xgh);
xc_gnttab_close(_G(xgh));
CAMLreturn(Val_unit);
}
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);
}
int main(int argc, char **argv)
{
struct event xs_event, xs_back_event;
int xs_fd, xs_back_fd;
if (argc != 1)
return 1;
/* Globals init */
xcg_handle = NULL;
/* Initialize XenStore */
xs_fd = superxenstore_init();
if (xs_fd < 0)
return 1;
/* Initialize gnttab */
if (xcg_handle == NULL) {
xcg_handle = xc_gnttab_open(NULL, 0);
}
if (xcg_handle == NULL) {
superlog(LOG_ERR, "Failed to connect to xc");
return 1;
}
/* Initialize SuperHID */
superhid_init();
/* Initialize the backend */
xs_back_fd = superbackend_init();
input_grabber = -1;
event_init();
event_set(&xs_event, xs_fd, EV_READ | EV_PERSIST,
xenstore_handler, NULL);
event_add(&xs_event, NULL);
event_set(&xs_back_event, xs_back_fd, EV_READ | EV_PERSIST,
xenstore_back_handler, NULL);
event_add(&xs_back_event, NULL);
event_dispatch();
/* Cleanup */
superxenstore_close();
xc_gnttab_close(xcg_handle);
return 0;
}
/* Open an interface to gntshr or gnttab each time it is needed. */
int test_open_multiple() {
xc_gntshr *gntshr_if;
xc_gnttab *gnttab_if;
uint32_t refs[PAGE_COUNT];
uint32_t domids[PAGE_COUNT];
void* local_share;
void* remote_share;
int i;
int err;
gntshr_if = xc_gntshr_open(NULL, 0);
if(!gntshr_if) {
printf("Failed to open gntshr interface.\n");
return 1;
}
gnttab_if = xc_gnttab_open(NULL, 0);
if(!gnttab_if) {
printf("Failed to open gnttab interface.\n");
return 1;
}
local_share = xc_gntshr_share_pages(gntshr_if, DOMID, PAGE_COUNT, refs, 0);
if(!local_share) {
printf("Failed to share memory.\n");
return 1;
}
for(i = 0; i < PAGE_COUNT; i++) {
printf("Sharing page with ref %d.\n", refs[i]);
}
for(i = 0; i < PAGE_COUNT; i++) {
domids[i] = DOMID;
}
remote_share = xc_gnttab_map_grant_refs(
gnttab_if,
PAGE_COUNT,
domids,
refs,
PROT_READ);
if(!remote_share) {
printf("Failed to map memory.\n");
return 1;
}
if(xc_gntshr_close(gntshr_if)) {
printf("Failed to close gntshr interface.\n");
return 1;
}
if(xc_gnttab_close(gnttab_if)) {
printf("Failed to close gnttab interface.\n");
return 1;
}
gntshr_if = xc_gntshr_open(NULL, 0);
if(!gntshr_if) {
printf("Failed to open gntshr interface.\n");
return 1;
}
gnttab_if = xc_gnttab_open(NULL, 0);
if(!gnttab_if) {
printf("Failed to open gnttab interface.\n");
return 1;
}
err = xc_gnttab_munmap(gnttab_if, remote_share, 1);
if(err) {
printf("Failed to unmap memory - got error code %d.\n", err);
return 1;
}
err = xc_gntshr_munmap(gntshr_if, local_share, 1);
if(err) {
printf("Failed to unshare memory - got error code %d.\n", err);
return 1;
}
if(xc_gntshr_close(gntshr_if)) {
printf("Failed to close gntshr interface.\n");
return 1;
}
if(xc_gnttab_close(gnttab_if)) {
printf("Failed to close gnttab interface.\n");
return 1;
}
return 0;
}
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);
}
