mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xen: Rename xen_be_printf to xen_pv_printf

Browse Source 
Prepare xen_be_printf to be used by both backend and frontends:
 * xen_be_printf -> xen_pv_printf

Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
Signed-off-by: Stefano Stabellini <sstabellini@kernel.org>
Signed-off-by: Quan Xu <xuquan8@huawei.com>
Acked-by: Anthony PERARD <anthony.perard@citrix.com>
This commit is contained in:
Emil Condrea 2016-10-25 08:50:14 +03:00 committed by Stefano Stabellini
parent ecf7981891
commit 96c77dba6f
10 changed files with 117 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
hw/block/xen_disk.c
View File

@ -167,12 +167,12 @@ static void destroy_grant(gpointer pgnt)
xengnttab_handle *gnt = grant->blkdev->xendev.gnttabdev; xengnttab_handle *gnt = grant->blkdev->xendev.gnttabdev;
if (xengnttab_unmap(gnt, grant->page, 1) != 0) { if (xengnttab_unmap(gnt, grant->page, 1) != 0) {
xen_be_printf(&grant->blkdev->xendev, 0, xen_pv_printf(&grant->blkdev->xendev, 0,
"xengnttab_unmap failed: %s\n", "xengnttab_unmap failed: %s\n",
strerror(errno)); strerror(errno));
} }
grant->blkdev->persistent_gnt_count--; grant->blkdev->persistent_gnt_count--;
xen_be_printf(&grant->blkdev->xendev, 3, xen_pv_printf(&grant->blkdev->xendev, 3,
"unmapped grant %p\n", grant->page); "unmapped grant %p\n", grant->page);
g_free(grant); g_free(grant);
} }
@ -184,11 +184,11 @@ static void remove_persistent_region(gpointer data, gpointer dev)
xengnttab_handle *gnt = blkdev->xendev.gnttabdev; xengnttab_handle *gnt = blkdev->xendev.gnttabdev;
if (xengnttab_unmap(gnt, region->addr, region->num) != 0) { if (xengnttab_unmap(gnt, region->addr, region->num) != 0) {
xen_be_printf(&blkdev->xendev, 0, xen_pv_printf(&blkdev->xendev, 0,
"xengnttab_unmap region %p failed: %s\n", "xengnttab_unmap region %p failed: %s\n",
region->addr, strerror(errno)); region->addr, strerror(errno));
} }
xen_be_printf(&blkdev->xendev, 3, xen_pv_printf(&blkdev->xendev, 3,
"unmapped grant region %p with %d pages\n", "unmapped grant region %p with %d pages\n",
region->addr, region->num); region->addr, region->num);
g_free(region); g_free(region);
@ -255,7 +255,7 @@ static int ioreq_parse(struct ioreq *ioreq)
size_t len; size_t len;
int i; int i;
xen_be_printf(&blkdev->xendev, 3, xen_pv_printf(&blkdev->xendev, 3,
"op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 "\n", "op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 "\n",
ioreq->req.operation, ioreq->req.nr_segments, ioreq->req.operation, ioreq->req.nr_segments,
ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number); ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number);
@ -275,28 +275,28 @@ static int ioreq_parse(struct ioreq *ioreq)
case BLKIF_OP_DISCARD: case BLKIF_OP_DISCARD:
return 0; return 0;
default: default:
xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n", xen_pv_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n",
ioreq->req.operation); ioreq->req.operation);
goto err; goto err;
}; };
if (ioreq->req.operation != BLKIF_OP_READ && blkdev->mode[0] != 'w') { if (ioreq->req.operation != BLKIF_OP_READ && blkdev->mode[0] != 'w') {
xen_be_printf(&blkdev->xendev, 0, "error: write req for ro device\n"); xen_pv_printf(&blkdev->xendev, 0, "error: write req for ro device\n");
goto err; goto err;
} }
ioreq->start = ioreq->req.sector_number * blkdev->file_blk; ioreq->start = ioreq->req.sector_number * blkdev->file_blk;
for (i = 0; i < ioreq->req.nr_segments; i++) { for (i = 0; i < ioreq->req.nr_segments; i++) {
if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) { if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) {
xen_be_printf(&blkdev->xendev, 0, "error: nr_segments too big\n"); xen_pv_printf(&blkdev->xendev, 0, "error: nr_segments too big\n");
goto err; goto err;
} }
if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) { if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) {
xen_be_printf(&blkdev->xendev, 0, "error: first > last sector\n"); xen_pv_printf(&blkdev->xendev, 0, "error: first > last sector\n");
goto err; goto err;
} }
if (ioreq->req.seg[i].last_sect * BLOCK_SIZE >= XC_PAGE_SIZE) { if (ioreq->req.seg[i].last_sect * BLOCK_SIZE >= XC_PAGE_SIZE) {
xen_be_printf(&blkdev->xendev, 0, "error: page crossing\n"); xen_pv_printf(&blkdev->xendev, 0, "error: page crossing\n");
goto err; goto err;
} }
@ -308,7 +308,7 @@ static int ioreq_parse(struct ioreq *ioreq)
qemu_iovec_add(&ioreq->v, (void*)mem, len); qemu_iovec_add(&ioreq->v, (void*)mem, len);
} }
if (ioreq->start + ioreq->v.size > blkdev->file_size) { if (ioreq->start + ioreq->v.size > blkdev->file_size) {
xen_be_printf(&blkdev->xendev, 0, "error: access beyond end of file\n"); xen_pv_printf(&blkdev->xendev, 0, "error: access beyond end of file\n");
goto err; goto err;
} }
return 0; return 0;
@ -331,7 +331,7 @@ static void ioreq_unmap(struct ioreq *ioreq)
return; return;
} }
if (xengnttab_unmap(gnt, ioreq->pages, ioreq->num_unmap) != 0) { if (xengnttab_unmap(gnt, ioreq->pages, ioreq->num_unmap) != 0) {
xen_be_printf(&ioreq->blkdev->xendev, 0, xen_pv_printf(&ioreq->blkdev->xendev, 0,
"xengnttab_unmap failed: %s\n", "xengnttab_unmap failed: %s\n",
strerror(errno)); strerror(errno));
} }
@ -343,7 +343,7 @@ static void ioreq_unmap(struct ioreq *ioreq)
continue; continue;
} }
if (xengnttab_unmap(gnt, ioreq->page[i], 1) != 0) { if (xengnttab_unmap(gnt, ioreq->page[i], 1) != 0) {
xen_be_printf(&ioreq->blkdev->xendev, 0, xen_pv_printf(&ioreq->blkdev->xendev, 0,
"xengnttab_unmap failed: %s\n", "xengnttab_unmap failed: %s\n",
strerror(errno)); strerror(errno));
} }
@ -381,7 +381,7 @@ static int ioreq_map(struct ioreq *ioreq)
if (grant != NULL) { if (grant != NULL) {
page[i] = grant->page; page[i] = grant->page;
xen_be_printf(&ioreq->blkdev->xendev, 3, xen_pv_printf(&ioreq->blkdev->xendev, 3,
"using persistent-grant %" PRIu32 "\n", "using persistent-grant %" PRIu32 "\n",
ioreq->refs[i]); ioreq->refs[i]);
} else { } else {
@ -410,7 +410,7 @@ static int ioreq_map(struct ioreq *ioreq)
ioreq->pages = xengnttab_map_grant_refs ioreq->pages = xengnttab_map_grant_refs
(gnt, new_maps, domids, refs, ioreq->prot); (gnt, new_maps, domids, refs, ioreq->prot);
if (ioreq->pages == NULL) { if (ioreq->pages == NULL) {
xen_be_printf(&ioreq->blkdev->xendev, 0, xen_pv_printf(&ioreq->blkdev->xendev, 0,
"can't map %d grant refs (%s, %d maps)\n", "can't map %d grant refs (%s, %d maps)\n",
new_maps, strerror(errno), ioreq->blkdev->cnt_map); new_maps, strerror(errno), ioreq->blkdev->cnt_map);
return -1; return -1;
@ -426,7 +426,7 @@ static int ioreq_map(struct ioreq *ioreq)
ioreq->page[i] = xengnttab_map_grant_ref ioreq->page[i] = xengnttab_map_grant_ref
(gnt, domids[i], refs[i], ioreq->prot); (gnt, domids[i], refs[i], ioreq->prot);
if (ioreq->page[i] == NULL) { if (ioreq->page[i] == NULL) {
xen_be_printf(&ioreq->blkdev->xendev, 0, xen_pv_printf(&ioreq->blkdev->xendev, 0,
"can't map grant ref %d (%s, %d maps)\n", "can't map grant ref %d (%s, %d maps)\n",
refs[i], strerror(errno), ioreq->blkdev->cnt_map); refs[i], strerror(errno), ioreq->blkdev->cnt_map);
ioreq->mapped = 1; ioreq->mapped = 1;
@ -474,7 +474,7 @@ static int ioreq_map(struct ioreq *ioreq)
grant->page = ioreq->page[new_maps]; grant->page = ioreq->page[new_maps];
} }
grant->blkdev = ioreq->blkdev; grant->blkdev = ioreq->blkdev;
xen_be_printf(&ioreq->blkdev->xendev, 3, xen_pv_printf(&ioreq->blkdev->xendev, 3,
"adding grant %" PRIu32 " page: %p\n", "adding grant %" PRIu32 " page: %p\n",
refs[new_maps], grant->page); refs[new_maps], grant->page);
g_tree_insert(ioreq->blkdev->persistent_gnts, g_tree_insert(ioreq->blkdev->persistent_gnts,
@ -557,7 +557,7 @@ static int ioreq_grant_copy(struct ioreq *ioreq)
rc = xengnttab_grant_copy(gnt, count, segs); rc = xengnttab_grant_copy(gnt, count, segs);
if (rc) { if (rc) {
xen_be_printf(&ioreq->blkdev->xendev, 0, xen_pv_printf(&ioreq->blkdev->xendev, 0,
"failed to copy data %d\n", rc); "failed to copy data %d\n", rc);
ioreq->aio_errors++; ioreq->aio_errors++;
return -1; return -1;
@ -565,7 +565,7 @@ static int ioreq_grant_copy(struct ioreq *ioreq)
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
if (segs[i].status != GNTST_okay) { if (segs[i].status != GNTST_okay) {
xen_be_printf(&ioreq->blkdev->xendev, 3, xen_pv_printf(&ioreq->blkdev->xendev, 3,
"failed to copy data %d for gref %d, domid %d\n", "failed to copy data %d for gref %d, domid %d\n",
segs[i].status, ioreq->refs[i], ioreq->domids[i]); segs[i].status, ioreq->refs[i], ioreq->domids[i]);
ioreq->aio_errors++; ioreq->aio_errors++;
@ -599,7 +599,7 @@ static void qemu_aio_complete(void *opaque, int ret)
struct ioreq *ioreq = opaque; struct ioreq *ioreq = opaque;
if (ret != 0) { if (ret != 0) {
xen_be_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n", xen_pv_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n",
ioreq->req.operation == BLKIF_OP_READ ? "read" : "write"); ioreq->req.operation == BLKIF_OP_READ ? "read" : "write");
ioreq->aio_errors++; ioreq->aio_errors++;
} }
@ -910,7 +910,7 @@ static void blk_alloc(struct XenDevice *xendev)
} }
if (xengnttab_set_max_grants(xendev->gnttabdev, if (xengnttab_set_max_grants(xendev->gnttabdev,
MAX_GRANTS(max_requests, BLKIF_MAX_SEGMENTS_PER_REQUEST)) < 0) { MAX_GRANTS(max_requests, BLKIF_MAX_SEGMENTS_PER_REQUEST)) < 0) {
xen_be_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
strerror(errno)); strerror(errno));
} }
} }
@ -1056,11 +1056,11 @@ static int blk_connect(struct XenDevice *xendev)
} }
/* setup via xenbus -> create new block driver instance */ /* setup via xenbus -> create new block driver instance */
xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); xen_pv_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n");
blkdev->blk = blk_new_open(blkdev->filename, NULL, options, blkdev->blk = blk_new_open(blkdev->filename, NULL, options,
qflags, &local_err); qflags, &local_err);
if (!blkdev->blk) { if (!blkdev->blk) {
xen_be_printf(&blkdev->xendev, 0, "error: %s\n", xen_pv_printf(&blkdev->xendev, 0, "error: %s\n",
error_get_pretty(local_err)); error_get_pretty(local_err));
error_free(local_err); error_free(local_err);
return -1; return -1;
@ -1068,11 +1068,11 @@ static int blk_connect(struct XenDevice *xendev)
blk_set_enable_write_cache(blkdev->blk, !writethrough); blk_set_enable_write_cache(blkdev->blk, !writethrough);
} else { } else {
/* setup via qemu cmdline -> already setup for us */ /* setup via qemu cmdline -> already setup for us */
xen_be_printf(&blkdev->xendev, 2, xen_pv_printf(&blkdev->xendev, 2,
"get configured bdrv (cmdline setup)\n"); "get configured bdrv (cmdline setup)\n");
blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo); blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo);
if (blk_is_read_only(blkdev->blk) && !readonly) { if (blk_is_read_only(blkdev->blk) && !readonly) {
xen_be_printf(&blkdev->xendev, 0, "Unexpected read-only drive"); xen_pv_printf(&blkdev->xendev, 0, "Unexpected read-only drive");
blkdev->blk = NULL; blkdev->blk = NULL;
return -1; return -1;
} }
@ -1085,13 +1085,13 @@ static int blk_connect(struct XenDevice *xendev)
if (blkdev->file_size < 0) { if (blkdev->file_size < 0) {
BlockDriverState *bs = blk_bs(blkdev->blk); BlockDriverState *bs = blk_bs(blkdev->blk);
const char *drv_name = bs ? bdrv_get_format_name(bs) : NULL; const char *drv_name = bs ? bdrv_get_format_name(bs) : NULL;
xen_be_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n", xen_pv_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n",
(int)blkdev->file_size, strerror(-blkdev->file_size), (int)blkdev->file_size, strerror(-blkdev->file_size),
drv_name ?: "-"); drv_name ?: "-");
blkdev->file_size = 0; blkdev->file_size = 0;
} }
xen_be_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\"," xen_pv_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\","
" size %" PRId64 " (%" PRId64 " MB)\n", " size %" PRId64 " (%" PRId64 " MB)\n",
blkdev->type, blkdev->fileproto, blkdev->filename, blkdev->type, blkdev->fileproto, blkdev->filename,
blkdev->file_size, blkdev->file_size >> 20); blkdev->file_size, blkdev->file_size >> 20);
@ -1175,10 +1175,10 @@ static int blk_connect(struct XenDevice *xendev)
blkdev->feature_grant_copy = blkdev->feature_grant_copy =
(xengnttab_grant_copy(blkdev->xendev.gnttabdev, 0, NULL) == 0); (xengnttab_grant_copy(blkdev->xendev.gnttabdev, 0, NULL) == 0);
xen_be_printf(&blkdev->xendev, 3, "grant copy operation %s\n", xen_pv_printf(&blkdev->xendev, 3, "grant copy operation %s\n",
blkdev->feature_grant_copy ? "enabled" : "disabled"); blkdev->feature_grant_copy ? "enabled" : "disabled");
xen_be_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, " xen_pv_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, "
"remote port %d, local port %d\n", "remote port %d, local port %d\n",
blkdev->xendev.protocol, blkdev->ring_ref, blkdev->xendev.protocol, blkdev->ring_ref,
blkdev->xendev.remote_port, blkdev->xendev.local_port); blkdev->xendev.remote_port, blkdev->xendev.local_port);

8
hw/char/xen_console.c
View File

@ -160,14 +160,14 @@ static void xencons_send(struct XenConsole *con)
if (len < 1) { if (len < 1) {
if (!con->backlog) { if (!con->backlog) {
con->backlog = 1; con->backlog = 1;
xen_be_printf(&con->xendev, 1, xen_pv_printf(&con->xendev, 1,
"backlog piling up, nobody listening?\n"); "backlog piling up, nobody listening?\n");
} }
} else { } else {
buffer_advance(&con->buffer, len); buffer_advance(&con->buffer, len);
if (con->backlog && len == size) { if (con->backlog && len == size) {
con->backlog = 0; con->backlog = 0;
xen_be_printf(&con->xendev, 1, "backlog is gone\n"); xen_pv_printf(&con->xendev, 1, "backlog is gone\n");
} }
} }
} }
@ -192,7 +192,7 @@ static int con_init(struct XenDevice *xendev)
type = xenstore_read_str(con->console, "type"); type = xenstore_read_str(con->console, "type");
if (!type || strcmp(type, "ioemu") != 0) { if (!type || strcmp(type, "ioemu") != 0) {
xen_be_printf(xendev, 1, "not for me (type=%s)\n", type); xen_pv_printf(xendev, 1, "not for me (type=%s)\n", type);
ret = -1; ret = -1;
goto out; goto out;
} }
@ -248,7 +248,7 @@ static int con_initialise(struct XenDevice *xendev)
qemu_chr_fe_set_handlers(&con->chr, xencons_can_receive, qemu_chr_fe_set_handlers(&con->chr, xencons_can_receive,
xencons_receive, NULL, con, NULL, true); xencons_receive, NULL, con, NULL, true);
xen_be_printf(xendev, 1, xen_pv_printf(xendev, 1,
"ring mfn %d, remote port %d, local port %d, limit %zd\n", "ring mfn %d, remote port %d, local port %d, limit %zd\n",
con->ring_ref, con->ring_ref,
con->xendev.remote_port, con->xendev.remote_port,

42
hw/display/xenfb.c
View File

@ -103,7 +103,7 @@ static int common_bind(struct common *c)
return -1; return -1;
xen_be_bind_evtchn(&c->xendev); xen_be_bind_evtchn(&c->xendev);
xen_be_printf(&c->xendev, 1, xen_pv_printf(&c->xendev, 1,
"ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n", "ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n",
mfn, c->xendev.remote_port, c->xendev.local_port); mfn, c->xendev.remote_port, c->xendev.local_port);
@ -346,7 +346,7 @@ static int input_initialise(struct XenDevice *xendev)
int rc; int rc;
if (!in->c.con) { if (!in->c.con) {
xen_be_printf(xendev, 1, "ds not set (yet)\n"); xen_pv_printf(xendev, 1, "ds not set (yet)\n");
return -1; return -1;
} }
@ -511,44 +511,44 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim,
int max_width, max_height; int max_width, max_height;
if (fb_len_lim > fb_len_max) { if (fb_len_lim > fb_len_max) {
xen_be_printf(&xenfb->c.xendev, 0, xen_pv_printf(&xenfb->c.xendev, 0,
"fb size limit %zu exceeds %zu, corrected\n", "fb size limit %zu exceeds %zu, corrected\n",
fb_len_lim, fb_len_max); fb_len_lim, fb_len_max);
fb_len_lim = fb_len_max; fb_len_lim = fb_len_max;
} }
if (fb_len_lim && fb_len > fb_len_lim) { if (fb_len_lim && fb_len > fb_len_lim) {
xen_be_printf(&xenfb->c.xendev, 0, xen_pv_printf(&xenfb->c.xendev, 0,
"frontend fb size %zu limited to %zu\n", "frontend fb size %zu limited to %zu\n",
fb_len, fb_len_lim); fb_len, fb_len_lim);
fb_len = fb_len_lim; fb_len = fb_len_lim;
} }
if (depth != 8 && depth != 16 && depth != 24 && depth != 32) { if (depth != 8 && depth != 16 && depth != 24 && depth != 32) {
xen_be_printf(&xenfb->c.xendev, 0, xen_pv_printf(&xenfb->c.xendev, 0,
"can't handle frontend fb depth %d\n", "can't handle frontend fb depth %d\n",
depth); depth);
return -1; return -1;
} }
if (row_stride <= 0 || row_stride > fb_len) { if (row_stride <= 0 || row_stride > fb_len) {
xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n",
row_stride); row_stride);
return -1; return -1;
} }
max_width = row_stride / (depth / 8); max_width = row_stride / (depth / 8);
if (width < 0 || width > max_width) { if (width < 0 || width > max_width) {
xen_be_printf(&xenfb->c.xendev, 0, xen_pv_printf(&xenfb->c.xendev, 0,
"invalid frontend width %d limited to %d\n", "invalid frontend width %d limited to %d\n",
width, max_width); width, max_width);
width = max_width; width = max_width;
} }
if (offset < 0 || offset >= fb_len) { if (offset < 0 || offset >= fb_len) {
xen_be_printf(&xenfb->c.xendev, 0, xen_pv_printf(&xenfb->c.xendev, 0,
"invalid frontend offset %d (max %zu)\n", "invalid frontend offset %d (max %zu)\n",
offset, fb_len - 1); offset, fb_len - 1);
return -1; return -1;
} }
max_height = (fb_len - offset) / row_stride; max_height = (fb_len - offset) / row_stride;
if (height < 0 || height > max_height) { if (height < 0 || height > max_height) {
xen_be_printf(&xenfb->c.xendev, 0, xen_pv_printf(&xenfb->c.xendev, 0,
"invalid frontend height %d limited to %d\n", "invalid frontend height %d limited to %d\n",
height, max_height); height, max_height);
height = max_height; height = max_height;
@ -561,7 +561,7 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim,
xenfb->offset = offset; xenfb->offset = offset;
xenfb->up_fullscreen = 1; xenfb->up_fullscreen = 1;
xenfb->do_resize = 1; xenfb->do_resize = 1;
xen_be_printf(&xenfb->c.xendev, 1, xen_pv_printf(&xenfb->c.xendev, 1,
"framebuffer %dx%dx%d offset %d stride %d\n", "framebuffer %dx%dx%d offset %d stride %d\n",
width, height, depth, offset, row_stride); width, height, depth, offset, row_stride);
return 0; return 0;
@ -640,7 +640,7 @@ static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h)
} }
} }
if (oops) /* should not happen */ if (oops) /* should not happen */
xen_be_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n", xen_pv_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n",
__FUNCTION__, xenfb->depth, bpp); __FUNCTION__, xenfb->depth, bpp);
dpy_gfx_update(xenfb->c.con, x, y, w, h); dpy_gfx_update(xenfb->c.con, x, y, w, h);
@ -730,7 +730,7 @@ static void xenfb_update(void *opaque)
break; break;
} }
dpy_gfx_replace_surface(xenfb->c.con, surface); dpy_gfx_replace_surface(xenfb->c.con, surface);
xen_be_printf(&xenfb->c.xendev, 1, xen_pv_printf(&xenfb->c.xendev, 1,
"update: resizing: %dx%d @ %d bpp%s\n", "update: resizing: %dx%d @ %d bpp%s\n",
xenfb->width, xenfb->height, xenfb->depth, xenfb->width, xenfb->height, xenfb->depth,
is_buffer_shared(surface) ? " (shared)" : ""); is_buffer_shared(surface) ? " (shared)" : "");
@ -739,10 +739,10 @@ static void xenfb_update(void *opaque)
/* run queued updates */ /* run queued updates */
if (xenfb->up_fullscreen) { if (xenfb->up_fullscreen) {
xen_be_printf(&xenfb->c.xendev, 3, "update: fullscreen\n"); xen_pv_printf(&xenfb->c.xendev, 3, "update: fullscreen\n");
xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height); xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
} else if (xenfb->up_count) { } else if (xenfb->up_count) {
xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xen_pv_printf(&xenfb->c.xendev, 3, "update: %d rects\n",
xenfb->up_count); xenfb->up_count);
for (i = 0; i < xenfb->up_count; i++) for (i = 0; i < xenfb->up_count; i++)
xenfb_guest_copy(xenfb, xenfb_guest_copy(xenfb,
@ -751,7 +751,7 @@ static void xenfb_update(void *opaque)
xenfb->up_rects[i].w, xenfb->up_rects[i].w,
xenfb->up_rects[i].h); xenfb->up_rects[i].h);
} else { } else {
xen_be_printf(&xenfb->c.xendev, 3, "update: nothing\n"); xen_pv_printf(&xenfb->c.xendev, 3, "update: nothing\n");
} }
xenfb->up_count = 0; xenfb->up_count = 0;
xenfb->up_fullscreen = 0; xenfb->up_fullscreen = 0;
@ -805,14 +805,14 @@ static void xenfb_handle_events(struct XenFB *xenfb)
w = MIN(event->update.width, xenfb->width - x); w = MIN(event->update.width, xenfb->width - x);
h = MIN(event->update.height, xenfb->height - y); h = MIN(event->update.height, xenfb->height - y);
if (w < 0 || h < 0) { if (w < 0 || h < 0) {
xen_be_printf(&xenfb->c.xendev, 1, "bogus update ignored\n"); xen_pv_printf(&xenfb->c.xendev, 1, "bogus update ignored\n");
break; break;
} }
if (x != event->update.x || if (x != event->update.x ||
y != event->update.y || y != event->update.y ||
w != event->update.width || w != event->update.width ||
h != event->update.height) { h != event->update.height) {
xen_be_printf(&xenfb->c.xendev, 1, "bogus update clipped\n"); xen_pv_printf(&xenfb->c.xendev, 1, "bogus update clipped\n");
} }
if (w == xenfb->width && h > xenfb->height / 2) { if (w == xenfb->width && h > xenfb->height / 2) {
/* scroll detector: updated more than 50% of the lines, /* scroll detector: updated more than 50% of the lines,
@ -894,7 +894,7 @@ static int fb_initialise(struct XenDevice *xendev)
if (fb->feature_update) if (fb->feature_update)
xenstore_write_be_int(xendev, "request-update", 1); xenstore_write_be_int(xendev, "request-update", 1);
xen_be_printf(xendev, 1, "feature-update=%d, videoram=%d\n", xen_pv_printf(xendev, 1, "feature-update=%d, videoram=%d\n",
fb->feature_update, videoram); fb->feature_update, videoram);
return 0; return 0;
} }
@ -913,7 +913,7 @@ static void fb_disconnect(struct XenDevice *xendev)
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON,
-1, 0); -1, 0);
if (fb->pixels == MAP_FAILED) { if (fb->pixels == MAP_FAILED) {
xen_be_printf(xendev, 0, xen_pv_printf(xendev, 0,
"Couldn't replace the framebuffer with anonymous memory errno=%d\n", "Couldn't replace the framebuffer with anonymous memory errno=%d\n",
errno); errno);
} }
@ -934,7 +934,7 @@ static void fb_frontend_changed(struct XenDevice *xendev, const char *node)
if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 && if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 &&
xendev->fe_state == XenbusStateConnected && xendev->fe_state == XenbusStateConnected &&
xendev->be_state == XenbusStateConnected) { xendev->be_state == XenbusStateConnected) {
xen_be_printf(xendev, 2, "re-trigger connected (frontend bug)\n"); xen_pv_printf(xendev, 2, "re-trigger connected (frontend bug)\n");
xen_be_set_state(xendev, XenbusStateConnected); xen_be_set_state(xendev, XenbusStateConnected);
fb->bug_trigger = 1; /* only once */ fb->bug_trigger = 1; /* only once */
} }
@ -995,7 +995,7 @@ wait_more:
usleep(10000); usleep(10000);
goto wait_more; goto wait_more;
} }
xen_be_printf(NULL, 1, "displaystate setup failed\n"); xen_pv_printf(NULL, 1, "displaystate setup failed\n");
return; return;
} }

22
hw/net/xen_nic.c
View File

@ -128,31 +128,31 @@ static void net_tx_packets(struct XenNetDev *netdev)
/* should not happen in theory, we don't announce the * /* should not happen in theory, we don't announce the *
* feature-{sg,gso,whatelse} flags in xenstore (yet?) */ * feature-{sg,gso,whatelse} flags in xenstore (yet?) */
if (txreq.flags & NETTXF_extra_info) { if (txreq.flags & NETTXF_extra_info) {
xen_be_printf(&netdev->xendev, 0, "FIXME: extra info flag\n"); xen_pv_printf(&netdev->xendev, 0, "FIXME: extra info flag\n");
net_tx_error(netdev, &txreq, rc); net_tx_error(netdev, &txreq, rc);
continue; continue;
} }
if (txreq.flags & NETTXF_more_data) { if (txreq.flags & NETTXF_more_data) {
xen_be_printf(&netdev->xendev, 0, "FIXME: more data flag\n"); xen_pv_printf(&netdev->xendev, 0, "FIXME: more data flag\n");
net_tx_error(netdev, &txreq, rc); net_tx_error(netdev, &txreq, rc);
continue; continue;
} }
#endif #endif
if (txreq.size < 14) { if (txreq.size < 14) {
xen_be_printf(&netdev->xendev, 0, "bad packet size: %d\n", xen_pv_printf(&netdev->xendev, 0, "bad packet size: %d\n",
txreq.size); txreq.size);
net_tx_error(netdev, &txreq, rc); net_tx_error(netdev, &txreq, rc);
continue; continue;
} }
if ((txreq.offset + txreq.size) > XC_PAGE_SIZE) { if ((txreq.offset + txreq.size) > XC_PAGE_SIZE) {
xen_be_printf(&netdev->xendev, 0, "error: page crossing\n"); xen_pv_printf(&netdev->xendev, 0, "error: page crossing\n");
net_tx_error(netdev, &txreq, rc); net_tx_error(netdev, &txreq, rc);
continue; continue;
} }
xen_be_printf(&netdev->xendev, 3, xen_pv_printf(&netdev->xendev, 3,
"tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n", "tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n",
txreq.gref, txreq.offset, txreq.size, txreq.flags, txreq.gref, txreq.offset, txreq.size, txreq.flags,
(txreq.flags & NETTXF_csum_blank) ? " csum_blank" : "", (txreq.flags & NETTXF_csum_blank) ? " csum_blank" : "",
@ -164,7 +164,7 @@ static void net_tx_packets(struct XenNetDev *netdev)
netdev->xendev.dom, netdev->xendev.dom,
txreq.gref, PROT_READ); txreq.gref, PROT_READ);
if (page == NULL) { if (page == NULL) {
xen_be_printf(&netdev->xendev, 0, xen_pv_printf(&netdev->xendev, 0,
"error: tx gref dereference failed (%d)\n", "error: tx gref dereference failed (%d)\n",
txreq.gref); txreq.gref);
net_tx_error(netdev, &txreq, rc); net_tx_error(netdev, &txreq, rc);
@ -214,7 +214,7 @@ static void net_rx_response(struct XenNetDev *netdev,
resp->status = (int16_t)st; resp->status = (int16_t)st;
} }
xen_be_printf(&netdev->xendev, 3, xen_pv_printf(&netdev->xendev, 3,
"rx response: idx %d, status %d, flags 0x%x\n", "rx response: idx %d, status %d, flags 0x%x\n",
i, resp->status, resp->flags); i, resp->status, resp->flags);
@ -246,7 +246,7 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size
return 0; return 0;
} }
if (size > XC_PAGE_SIZE - NET_IP_ALIGN) { if (size > XC_PAGE_SIZE - NET_IP_ALIGN) {
xen_be_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)", xen_pv_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)",
(unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN); (unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN);
return -1; return -1;
} }
@ -258,7 +258,7 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size
netdev->xendev.dom, netdev->xendev.dom,
rxreq.gref, PROT_WRITE); rxreq.gref, PROT_WRITE);
if (page == NULL) { if (page == NULL) {
xen_be_printf(&netdev->xendev, 0, xen_pv_printf(&netdev->xendev, 0,
"error: rx gref dereference failed (%d)\n", "error: rx gref dereference failed (%d)\n",
rxreq.gref); rxreq.gref);
net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0); net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0);
@ -333,7 +333,7 @@ static int net_connect(struct XenDevice *xendev)
rx_copy = 0; rx_copy = 0;
} }
if (rx_copy == 0) { if (rx_copy == 0) {
xen_be_printf(&netdev->xendev, 0, xen_pv_printf(&netdev->xendev, 0,
"frontend doesn't support rx-copy.\n"); "frontend doesn't support rx-copy.\n");
return -1; return -1;
} }
@ -359,7 +359,7 @@ static int net_connect(struct XenDevice *xendev)
xen_be_bind_evtchn(&netdev->xendev); xen_be_bind_evtchn(&netdev->xendev);
xen_be_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, " xen_pv_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, "
"remote port %d, local port %d\n", "remote port %d, local port %d\n",
netdev->tx_ring_ref, netdev->rx_ring_ref, netdev->tx_ring_ref, netdev->rx_ring_ref,
netdev->xendev.remote_port, netdev->xendev.local_port); netdev->xendev.remote_port, netdev->xendev.local_port);

38
hw/usb/xen-usb.c
View File

@ -47,7 +47,7 @@
struct timeval tv; \ struct timeval tv; \
\ \
gettimeofday(&tv, NULL); \ gettimeofday(&tv, NULL); \
xen_be_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \ xen_pv_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \
tv.tv_sec, tv.tv_usec, __func__, ##args); \ tv.tv_sec, tv.tv_usec, __func__, ##args); \
} }
#define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args) #define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args)
@ -153,7 +153,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req)
} }
if (nr_segs > USBIF_MAX_SEGMENTS_PER_REQUEST) { if (nr_segs > USBIF_MAX_SEGMENTS_PER_REQUEST) {
xen_be_printf(xendev, 0, "bad number of segments in request (%d)\n", xen_pv_printf(xendev, 0, "bad number of segments in request (%d)\n",
nr_segs); nr_segs);
return -EINVAL; return -EINVAL;
} }
@ -161,7 +161,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req)
for (i = 0; i < nr_segs; i++) { for (i = 0; i < nr_segs; i++) {
if ((unsigned)usbback_req->req.seg[i].offset + if ((unsigned)usbback_req->req.seg[i].offset +
(unsigned)usbback_req->req.seg[i].length > XC_PAGE_SIZE) { (unsigned)usbback_req->req.seg[i].length > XC_PAGE_SIZE) {
xen_be_printf(xendev, 0, "segment crosses page boundary\n"); xen_pv_printf(xendev, 0, "segment crosses page boundary\n");
return -EINVAL; return -EINVAL;
} }
} }
@ -199,7 +199,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req)
*/ */
if (!usbback_req->nr_extra_segs) { if (!usbback_req->nr_extra_segs) {
xen_be_printf(xendev, 0, "iso request without descriptor segments\n"); xen_pv_printf(xendev, 0, "iso request without descriptor segments\n");
return -EINVAL; return -EINVAL;
} }
@ -551,14 +551,14 @@ static void usbback_dispatch(struct usbback_req *usbback_req)
ret = usbback_init_packet(usbback_req); ret = usbback_init_packet(usbback_req);
if (ret) { if (ret) {
xen_be_printf(&usbif->xendev, 0, "invalid request\n"); xen_pv_printf(&usbif->xendev, 0, "invalid request\n");
ret = -ESHUTDOWN; ret = -ESHUTDOWN;
goto fail_free_urb; goto fail_free_urb;
} }
ret = usbback_gnttab_map(usbback_req); ret = usbback_gnttab_map(usbback_req);
if (ret) { if (ret) {
xen_be_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); xen_pv_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret);
ret = -ESHUTDOWN; ret = -ESHUTDOWN;
goto fail_free_urb; goto fail_free_urb;
} }
@ -646,7 +646,7 @@ static void usbback_bh(void *opaque)
if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) { if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) {
rc = urb_ring->rsp_prod_pvt; rc = urb_ring->rsp_prod_pvt;
xen_be_printf(&usbif->xendev, 0, "domU provided bogus ring requests " xen_pv_printf(&usbif->xendev, 0, "domU provided bogus ring requests "
"(%#x - %#x = %u). Halting ring processing.\n", "(%#x - %#x = %u). Halting ring processing.\n",
rp, rc, rp - rc); rp, rc, rp - rc);
usbif->ring_error = true; usbif->ring_error = true;
@ -744,7 +744,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
portname = strchr(busid, '-'); portname = strchr(busid, '-');
if (!portname) { if (!portname) {
xen_be_printf(&usbif->xendev, 0, "device %s illegal specification\n", xen_pv_printf(&usbif->xendev, 0, "device %s illegal specification\n",
busid); busid);
return; return;
} }
@ -783,7 +783,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
break; break;
} }
if (speed == USBIF_SPEED_NONE) { if (speed == USBIF_SPEED_NONE) {
xen_be_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); xen_pv_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid);
object_unparent(OBJECT(usbif->ports[port - 1].dev)); object_unparent(OBJECT(usbif->ports[port - 1].dev));
usbif->ports[port - 1].dev = NULL; usbif->ports[port - 1].dev = NULL;
return; return;
@ -800,7 +800,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
err: err:
QDECREF(qdict); QDECREF(qdict);
snprintf(p->path, sizeof(p->path), "%d", 99); snprintf(p->path, sizeof(p->path), "%d", 99);
xen_be_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid);
} }
static void usbback_process_port(struct usbback_info *usbif, unsigned port) static void usbback_process_port(struct usbback_info *usbif, unsigned port)
@ -811,7 +811,7 @@ static void usbback_process_port(struct usbback_info *usbif, unsigned port)
snprintf(node, sizeof(node), "port/%d", port); snprintf(node, sizeof(node), "port/%d", port);
busid = xenstore_read_be_str(&usbif->xendev, node); busid = xenstore_read_be_str(&usbif->xendev, node);
if (busid == NULL) { if (busid == NULL) {
xen_be_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); xen_pv_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node);
return; return;
} }
@ -868,15 +868,15 @@ static int usbback_connect(struct XenDevice *xendev)
usbif = container_of(xendev, struct usbback_info, xendev); usbif = container_of(xendev, struct usbback_info, xendev);
if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) { if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) {
xen_be_printf(xendev, 0, "error reading urb-ring-ref\n"); xen_pv_printf(xendev, 0, "error reading urb-ring-ref\n");
return -1; return -1;
} }
if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) { if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) {
xen_be_printf(xendev, 0, "error reading conn-ring-ref\n"); xen_pv_printf(xendev, 0, "error reading conn-ring-ref\n");
return -1; return -1;
} }
if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) { if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) {
xen_be_printf(xendev, 0, "error reading event-channel\n"); xen_pv_printf(xendev, 0, "error reading event-channel\n");
return -1; return -1;
} }
@ -887,7 +887,7 @@ static int usbback_connect(struct XenDevice *xendev)
conn_ring_ref, conn_ring_ref,
PROT_READ | PROT_WRITE); PROT_READ | PROT_WRITE);
if (!usbif->urb_sring || !usbif->conn_sring) { if (!usbif->urb_sring || !usbif->conn_sring) {
xen_be_printf(xendev, 0, "error mapping rings\n"); xen_pv_printf(xendev, 0, "error mapping rings\n");
usbback_disconnect(xendev); usbback_disconnect(xendev);
return -1; return -1;
} }
@ -899,7 +899,7 @@ static int usbback_connect(struct XenDevice *xendev)
xen_be_bind_evtchn(xendev); xen_be_bind_evtchn(xendev);
xen_be_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " xen_pv_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, "
"remote port %d, local port %d\n", urb_ring_ref, "remote port %d, local port %d\n", urb_ring_ref,
conn_ring_ref, xendev->remote_port, xendev->local_port); conn_ring_ref, xendev->remote_port, xendev->local_port);
@ -935,12 +935,12 @@ static int usbback_init(struct XenDevice *xendev)
if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) || if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) ||
usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) { usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) {
xen_be_printf(xendev, 0, "num-ports not readable or out of bounds\n"); xen_pv_printf(xendev, 0, "num-ports not readable or out of bounds\n");
return -1; return -1;
} }
if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) || if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) ||
(usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) { (usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) {
xen_be_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); xen_pv_printf(xendev, 0, "usb-ver not readable or out of bounds\n");
return -1; return -1;
} }
@ -1028,7 +1028,7 @@ static void usbback_alloc(struct XenDevice *xendev)
/* max_grants: for each request and for the rings (request and connect). */ /* max_grants: for each request and for the rings (request and connect). */
max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2; max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2;
if (xengnttab_set_max_grants(xendev->gnttabdev, max_grants) < 0) { if (xengnttab_set_max_grants(xendev->gnttabdev, max_grants) < 0) {
xen_be_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
strerror(errno)); strerror(errno));
} }
} }

46
hw/xen/xen_backend.c
View File

@ -100,7 +100,7 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
if (rc < 0) { if (rc < 0) {
return rc; return rc;
} }
xen_be_printf(xendev, 1, "backend state: %s -> %s\n", xen_pv_printf(xendev, 1, "backend state: %s -> %s\n",
xenbus_strstate(xendev->be_state), xenbus_strstate(state)); xenbus_strstate(xendev->be_state), xenbus_strstate(state));
xendev->be_state = state; xendev->be_state = state;
return 0; return 0;
@ -136,7 +136,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
xendev->evtchndev = xenevtchn_open(NULL, 0); xendev->evtchndev = xenevtchn_open(NULL, 0);
if (xendev->evtchndev == NULL) { if (xendev->evtchndev == NULL) {
xen_be_printf(NULL, 0, "can't open evtchn device\n"); xen_pv_printf(NULL, 0, "can't open evtchn device\n");
g_free(xendev); g_free(xendev);
return NULL; return NULL;
} }
@ -145,7 +145,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) { if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
xendev->gnttabdev = xengnttab_open(NULL, 0); xendev->gnttabdev = xengnttab_open(NULL, 0);
if (xendev->gnttabdev == NULL) { if (xendev->gnttabdev == NULL) {
xen_be_printf(NULL, 0, "can't open gnttab device\n"); xen_pv_printf(NULL, 0, "can't open gnttab device\n");
xenevtchn_close(xendev->evtchndev); xenevtchn_close(xendev->evtchndev);
g_free(xendev); g_free(xendev);
return NULL; return NULL;
@ -178,7 +178,7 @@ static void xen_be_backend_changed(struct XenDevice *xendev, const char *node)
} }
if (node) { if (node) {
xen_be_printf(xendev, 2, "backend update: %s\n", node); xen_pv_printf(xendev, 2, "backend update: %s\n", node);
if (xendev->ops->backend_changed) { if (xendev->ops->backend_changed) {
xendev->ops->backend_changed(xendev, node); xendev->ops->backend_changed(xendev, node);
} }
@ -194,7 +194,7 @@ static void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
fe_state = XenbusStateUnknown; fe_state = XenbusStateUnknown;
} }
if (xendev->fe_state != fe_state) { if (xendev->fe_state != fe_state) {
xen_be_printf(xendev, 1, "frontend state: %s -> %s\n", xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n",
xenbus_strstate(xendev->fe_state), xenbus_strstate(xendev->fe_state),
xenbus_strstate(fe_state)); xenbus_strstate(fe_state));
} }
@ -204,13 +204,13 @@ static void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
g_free(xendev->protocol); g_free(xendev->protocol);
xendev->protocol = xenstore_read_fe_str(xendev, "protocol"); xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
if (xendev->protocol) { if (xendev->protocol) {
xen_be_printf(xendev, 1, "frontend protocol: %s\n", xen_pv_printf(xendev, 1, "frontend protocol: %s\n",
xendev->protocol); xendev->protocol);
} }
} }
if (node) { if (node) {
xen_be_printf(xendev, 2, "frontend update: %s\n", node); xen_pv_printf(xendev, 2, "frontend update: %s\n", node);
if (xendev->ops->frontend_changed) { if (xendev->ops->frontend_changed) {
xendev->ops->frontend_changed(xendev, node); xendev->ops->frontend_changed(xendev, node);
} }
@ -234,26 +234,26 @@ static int xen_be_try_setup(struct XenDevice *xendev)
int be_state; int be_state;
if (xenstore_read_be_int(xendev, "state", &be_state) == -1) { if (xenstore_read_be_int(xendev, "state", &be_state) == -1) {
xen_be_printf(xendev, 0, "reading backend state failed\n"); xen_pv_printf(xendev, 0, "reading backend state failed\n");
return -1; return -1;
} }
if (be_state != XenbusStateInitialising) { if (be_state != XenbusStateInitialising) {
xen_be_printf(xendev, 0, "initial backend state is wrong (%s)\n", xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n",
xenbus_strstate(be_state)); xenbus_strstate(be_state));
return -1; return -1;
} }
xendev->fe = xenstore_read_be_str(xendev, "frontend"); xendev->fe = xenstore_read_be_str(xendev, "frontend");
if (xendev->fe == NULL) { if (xendev->fe == NULL) {
xen_be_printf(xendev, 0, "reading frontend path failed\n"); xen_pv_printf(xendev, 0, "reading frontend path failed\n");
return -1; return -1;
} }
/* setup frontend watch */ /* setup frontend watch */
snprintf(token, sizeof(token), "fe:%p", xendev); snprintf(token, sizeof(token), "fe:%p", xendev);
if (!xs_watch(xenstore, xendev->fe, token)) { if (!xs_watch(xenstore, xendev->fe, token)) {
xen_be_printf(xendev, 0, "watching frontend path (%s) failed\n", xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n",
xendev->fe); xendev->fe);
return -1; return -1;
} }
@ -277,7 +277,7 @@ static int xen_be_try_init(struct XenDevice *xendev)
int rc = 0; int rc = 0;
if (!xendev->online) { if (!xendev->online) {
xen_be_printf(xendev, 1, "not online\n"); xen_pv_printf(xendev, 1, "not online\n");
return -1; return -1;
} }
@ -285,7 +285,7 @@ static int xen_be_try_init(struct XenDevice *xendev)
rc = xendev->ops->init(xendev); rc = xendev->ops->init(xendev);
} }
if (rc != 0) { if (rc != 0) {
xen_be_printf(xendev, 1, "init() failed\n"); xen_pv_printf(xendev, 1, "init() failed\n");
return rc; return rc;
} }
@ -308,9 +308,9 @@ static int xen_be_try_initialise(struct XenDevice *xendev)
if (xendev->fe_state != XenbusStateInitialised && if (xendev->fe_state != XenbusStateInitialised &&
xendev->fe_state != XenbusStateConnected) { xendev->fe_state != XenbusStateConnected) {
if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
xen_be_printf(xendev, 2, "frontend not ready, ignoring\n"); xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
} else { } else {
xen_be_printf(xendev, 2, "frontend not ready (yet)\n"); xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
return -1; return -1;
} }
} }
@ -319,7 +319,7 @@ static int xen_be_try_initialise(struct XenDevice *xendev)
rc = xendev->ops->initialise(xendev); rc = xendev->ops->initialise(xendev);
} }
if (rc != 0) { if (rc != 0) {
xen_be_printf(xendev, 0, "initialise() failed\n"); xen_pv_printf(xendev, 0, "initialise() failed\n");
return rc; return rc;
} }
@ -340,9 +340,9 @@ static void xen_be_try_connected(struct XenDevice *xendev)
if (xendev->fe_state != XenbusStateConnected) { if (xendev->fe_state != XenbusStateConnected) {
if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
xen_be_printf(xendev, 2, "frontend not ready, ignoring\n"); xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
} else { } else {
xen_be_printf(xendev, 2, "frontend not ready (yet)\n"); xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
return; return;
} }
} }
@ -376,7 +376,7 @@ static int xen_be_try_reset(struct XenDevice *xendev)
return -1; return -1;
} }
xen_be_printf(xendev, 1, "device reset (for re-connect)\n"); xen_pv_printf(xendev, 1, "device reset (for re-connect)\n");
xen_be_set_state(xendev, XenbusStateInitialising); xen_be_set_state(xendev, XenbusStateInitialising);
return 0; return 0;
} }
@ -437,7 +437,7 @@ static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops); snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops);
snprintf(path, sizeof(path), "backend/%s/%d", type, dom); snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
if (!xs_watch(xenstore, path, token)) { if (!xs_watch(xenstore, path, token)) {
xen_be_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n",
path); path);
return -1; return -1;
} }
@ -515,7 +515,7 @@ int xen_be_init(void)
{ {
xenstore = xs_daemon_open(); xenstore = xs_daemon_open();
if (!xenstore) { if (!xenstore) {
xen_be_printf(NULL, 0, "can't connect to xenstored\n"); xen_pv_printf(NULL, 0, "can't connect to xenstored\n");
return -1; return -1;
} }
@ -576,10 +576,10 @@ int xen_be_bind_evtchn(struct XenDevice *xendev)
xendev->local_port = xenevtchn_bind_interdomain xendev->local_port = xenevtchn_bind_interdomain
(xendev->evtchndev, xendev->dom, xendev->remote_port); (xendev->evtchndev, xendev->dom, xendev->remote_port);
if (xendev->local_port == -1) { if (xendev->local_port == -1) {
xen_be_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n"); xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n");
return -1; return -1;
} }
xen_be_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port); xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
xen_be_evtchn_event, NULL, xendev); xen_be_evtchn_event, NULL, xendev);
return 0; return 0;

4
hw/xen/xen_devconfig.c
View File

@ -55,7 +55,7 @@ int xen_config_dev_blk(DriveInfo *disk)
const char *filename = qemu_opt_get(disk->opts, "file"); const char *filename = qemu_opt_get(disk->opts, "file");
snprintf(device_name, sizeof(device_name), "xvd%c", 'a' + disk->unit); snprintf(device_name, sizeof(device_name), "xvd%c", 'a' + disk->unit);
xen_be_printf(NULL, 1, "config disk %d [%s]: %s\n", xen_pv_printf(NULL, 1, "config disk %d [%s]: %s\n",
disk->unit, device_name, filename); disk->unit, device_name, filename);
xen_config_dev_dirs("vbd", "qdisk", vdev, fe, be, sizeof(fe)); xen_config_dev_dirs("vbd", "qdisk", vdev, fe, be, sizeof(fe));
@ -83,7 +83,7 @@ int xen_config_dev_nic(NICInfo *nic)
snprintf(mac, sizeof(mac), "%02x:%02x:%02x:%02x:%02x:%02x", snprintf(mac, sizeof(mac), "%02x:%02x:%02x:%02x:%02x:%02x",
nic->macaddr.a[0], nic->macaddr.a[1], nic->macaddr.a[2], nic->macaddr.a[0], nic->macaddr.a[1], nic->macaddr.a[2],
nic->macaddr.a[3], nic->macaddr.a[4], nic->macaddr.a[5]); nic->macaddr.a[3], nic->macaddr.a[4], nic->macaddr.a[5]);
xen_be_printf(NULL, 1, "config nic %d: mac=\"%s\"\n", vlan_id, mac); xen_pv_printf(NULL, 1, "config nic %d: mac=\"%s\"\n", vlan_id, mac);
xen_config_dev_dirs("vif", "qnic", vlan_id, fe, be, sizeof(fe)); xen_config_dev_dirs("vif", "qnic", vlan_id, fe, be, sizeof(fe));
/* frontend */ /* frontend */

10
hw/xen/xen_pvdev.c
View File

@ -68,13 +68,13 @@ int xenstore_mkdir(char *path, int p)
}; };
if (!xs_mkdir(xenstore, 0, path)) { if (!xs_mkdir(xenstore, 0, path)) {
xen_be_printf(NULL, 0, "xs_mkdir %s: failed\n", path); xen_pv_printf(NULL, 0, "xs_mkdir %s: failed\n", path);
return -1; return -1;
} }
xenstore_cleanup_dir(g_strdup(path)); xenstore_cleanup_dir(g_strdup(path));
if (!xs_set_permissions(xenstore, 0, path, perms, 2)) { if (!xs_set_permissions(xenstore, 0, path, perms, 2)) {
xen_be_printf(NULL, 0, "xs_set_permissions %s: failed\n", path); xen_pv_printf(NULL, 0, "xs_set_permissions %s: failed\n", path);
return -1; return -1;
} }
return 0; return 0;
@ -194,7 +194,7 @@ const char *xenbus_strstate(enum xenbus_state state)
* 2 == noisy debug messages (logfile only). * 2 == noisy debug messages (logfile only).
* 3 == will flood your log (logfile only). * 3 == will flood your log (logfile only).
*/ */
void xen_be_printf(struct XenDevice *xendev, int msg_level, void xen_pv_printf(struct XenDevice *xendev, int msg_level,
const char *fmt, ...) const char *fmt, ...)
{ {
va_list args; va_list args;
@ -234,7 +234,7 @@ void xen_be_evtchn_event(void *opaque)
port = xenevtchn_pending(xendev->evtchndev); port = xenevtchn_pending(xendev->evtchndev);
if (port != xendev->local_port) { if (port != xendev->local_port) {
xen_be_printf(xendev, 0, xen_pv_printf(xendev, 0,
"xenevtchn_pending returned %d (expected %d)\n", "xenevtchn_pending returned %d (expected %d)\n",
port, xendev->local_port); port, xendev->local_port);
return; return;
@ -253,7 +253,7 @@ void xen_be_unbind_evtchn(struct XenDevice *xendev)
} }
qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), NULL, NULL, NULL); qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), NULL, NULL, NULL);
xenevtchn_unbind(xendev->evtchndev, xendev->local_port); xenevtchn_unbind(xendev->evtchndev, xendev->local_port);
xen_be_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port); xen_pv_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port);
xendev->local_port = -1; xendev->local_port = -1;
} }

2
include/hw/xen/xen_pvdev.h
View File

@ -72,7 +72,7 @@ struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
void xen_be_unbind_evtchn(struct XenDevice *xendev); void xen_be_unbind_evtchn(struct XenDevice *xendev);
int xen_be_send_notify(struct XenDevice *xendev); int xen_be_send_notify(struct XenDevice *xendev);
void xen_be_printf(struct XenDevice *xendev, int msg_level, void xen_pv_printf(struct XenDevice *xendev, int msg_level,
const char *fmt, ...) GCC_FMT_ATTR(3, 4); const char *fmt, ...) GCC_FMT_ATTR(3, 4);
#endif /* QEMU_HW_XEN_PVDEV_H */ #endif /* QEMU_HW_XEN_PVDEV_H */

4
xen-common.c
View File

@ -116,12 +116,12 @@ static int xen_init(MachineState *ms)
{ {
xen_xc = xc_interface_open(0, 0, 0); xen_xc = xc_interface_open(0, 0, 0);
if (xen_xc == NULL) { if (xen_xc == NULL) {
xen_be_printf(NULL, 0, "can't open xen interface\n"); xen_pv_printf(NULL, 0, "can't open xen interface\n");
return -1; return -1;
} }
xen_fmem = xenforeignmemory_open(0, 0); xen_fmem = xenforeignmemory_open(0, 0);
if (xen_fmem == NULL) { if (xen_fmem == NULL) {
xen_be_printf(NULL, 0, "can't open xen fmem interface\n"); xen_pv_printf(NULL, 0, "can't open xen fmem interface\n");
xc_interface_close(xen_xc); xc_interface_close(xen_xc);
return -1; return -1;
} }