Commit 5ff06787 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/sstabellini/tags/xen-20161028-tag' into staging 



Xen 2016/10/28

# gpg: Signature made Sat 29 Oct 2016 02:03:42 BST
# gpg:                using RSA key 0x894F8F4870E1AE90
# gpg: Good signature from "Stefano Stabellini <sstabellini@kernel.org>"
# gpg:                 aka "Stefano Stabellini <stefano.stabellini@eu.citrix.com>"
# Primary key fingerprint: D04E 33AB A51F 67BA 07D3  0AEA 894F 8F48 70E1 AE90

* remotes/sstabellini/tags/xen-20161028-tag:
  xen: Rename xen_be_del_xendev
  xen: Rename xen_be_find_xendev
  xen: Rename xen_be_evtchn_event
  xen: Rename xen_be_send_notify
  xen: Rename xen_be_unbind_evtchn
  xen: Rename xen_be_printf to xen_pv_printf
  xen: Move xenstore cleanup and mkdir functions
  xen: Prepare xendev qtail to be shared with frontends
  xen: Move evtchn functions to xen_pvdev.c
  xen: Move xenstore_update to xen_pvdev.c
  xen: Create a new file xen_pvdev.c
  xen: Fix coding style warnings
  xen: Fix coding style errors

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 277d44f5 71981364

hw/block/xen_disk.c

+33 −32
Original line number Diff line number Diff line
@@ -167,12 +167,12 @@ static void destroy_grant(gpointer pgnt) 
    xengnttab_handle *gnt = grant->blkdev->xendev.gnttabdev;



    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",

                      strerror(errno));

    }

    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);

    g_free(grant);

}
@@ -184,11 +184,11 @@ static void remove_persistent_region(gpointer data, gpointer dev) 
    xengnttab_handle *gnt = blkdev->xendev.gnttabdev;



    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",

                      region->addr, strerror(errno));

    }

    xen_be_printf(&blkdev->xendev, 3,

    xen_pv_printf(&blkdev->xendev, 3,

                  "unmapped grant region %p with %d pages\n",

                  region->addr, region->num);

    g_free(region);
@@ -255,7 +255,7 @@ static int ioreq_parse(struct ioreq *ioreq) 
    size_t len;

    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",

                  ioreq->req.operation, ioreq->req.nr_segments,

                  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:

        return 0;

    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);

        goto err;

    };



    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;

    }



    ioreq->start = ioreq->req.sector_number * blkdev->file_blk;

    for (i = 0; i < ioreq->req.nr_segments; i++) {

        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;

        }

        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;

        }

        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;

        }
@@ -308,7 +308,7 @@ static int ioreq_parse(struct ioreq *ioreq) 
        qemu_iovec_add(&ioreq->v, (void*)mem, len);

    }

    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;

    }

    return 0;
@@ -331,7 +331,7 @@ static void ioreq_unmap(struct ioreq *ioreq) 
            return;

        }

        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",

                          strerror(errno));

        }
@@ -343,7 +343,7 @@ static void ioreq_unmap(struct ioreq *ioreq) 
                continue;

            }

            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",

                              strerror(errno));

            }
@@ -381,7 +381,7 @@ static int ioreq_map(struct ioreq *ioreq) 


            if (grant != NULL) {

                page[i] = grant->page;

                xen_be_printf(&ioreq->blkdev->xendev, 3,

                xen_pv_printf(&ioreq->blkdev->xendev, 3,

                              "using persistent-grant %" PRIu32 "\n",

                              ioreq->refs[i]);

            } else {
@@ -410,7 +410,7 @@ static int ioreq_map(struct ioreq *ioreq) 
        ioreq->pages = xengnttab_map_grant_refs

            (gnt, new_maps, domids, refs, ioreq->prot);

        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",

                          new_maps, strerror(errno), ioreq->blkdev->cnt_map);

            return -1;
@@ -426,7 +426,7 @@ static int ioreq_map(struct ioreq *ioreq) 
            ioreq->page[i] = xengnttab_map_grant_ref

                (gnt, domids[i], refs[i], ioreq->prot);

            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",

                              refs[i], strerror(errno), ioreq->blkdev->cnt_map);

                ioreq->mapped = 1;
@@ -474,7 +474,7 @@ static int ioreq_map(struct ioreq *ioreq) 
                grant->page = ioreq->page[new_maps];

            }

            grant->blkdev = ioreq->blkdev;

            xen_be_printf(&ioreq->blkdev->xendev, 3,

            xen_pv_printf(&ioreq->blkdev->xendev, 3,

                          "adding grant %" PRIu32 " page: %p\n",

                          refs[new_maps], grant->page);

            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);



    if (rc) {

        xen_be_printf(&ioreq->blkdev->xendev, 0,

        xen_pv_printf(&ioreq->blkdev->xendev, 0,

                      "failed to copy data %d\n", rc);

        ioreq->aio_errors++;

        return -1;
@@ -565,7 +565,7 @@ static int ioreq_grant_copy(struct ioreq *ioreq) 


    for (i = 0; i < count; i++) {

        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",

                          segs[i].status, ioreq->refs[i], ioreq->domids[i]);

            ioreq->aio_errors++;
@@ -599,7 +599,7 @@ static void qemu_aio_complete(void *opaque, int ret) 
    struct ioreq *ioreq = opaque;



    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->aio_errors++;

    }
@@ -796,7 +796,7 @@ static void blk_send_response_all(struct XenBlkDev *blkdev) 
        ioreq_release(ioreq, true);

    }

    if (send_notify) {

        xen_be_send_notify(&blkdev->xendev);

        xen_pv_send_notify(&blkdev->xendev);

    }

}
@@ -866,7 +866,7 @@ static void blk_handle_requests(struct XenBlkDev *blkdev) 
            };



            if (blk_send_response_one(ioreq)) {

                xen_be_send_notify(&blkdev->xendev);

                xen_pv_send_notify(&blkdev->xendev);

            }

            ioreq_release(ioreq, false);

            continue;
@@ -910,7 +910,7 @@ static void blk_alloc(struct XenDevice *xendev) 
    }

    if (xengnttab_set_max_grants(xendev->gnttabdev,

            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));

    }

}
@@ -1056,11 +1056,11 @@ static int blk_connect(struct XenDevice *xendev) 
        }



        /* 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,

                                   qflags, &local_err);

        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_free(local_err);

            return -1;
@@ -1068,10 +1068,11 @@ static int blk_connect(struct XenDevice *xendev) 
        blk_set_enable_write_cache(blkdev->blk, !writethrough);

    } else {

        /* setup via qemu cmdline -> already setup for us */

        xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n");

        xen_pv_printf(&blkdev->xendev, 2,

                      "get configured bdrv (cmdline setup)\n");

        blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo);

        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;

            return -1;

        }
@@ -1084,13 +1085,13 @@ static int blk_connect(struct XenDevice *xendev) 
    if (blkdev->file_size < 0) {

        BlockDriverState *bs = blk_bs(blkdev->blk);

        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),

                      drv_name ?: "-");

        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",

                  blkdev->type, blkdev->fileproto, blkdev->filename,

                  blkdev->file_size, blkdev->file_size >> 20);
@@ -1174,10 +1175,10 @@ static int blk_connect(struct XenDevice *xendev) 
    blkdev->feature_grant_copy =

                (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");



    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",

                  blkdev->xendev.protocol, blkdev->ring_ref,

                  blkdev->xendev.remote_port, blkdev->xendev.local_port);
@@ -1193,7 +1194,7 @@ static void blk_disconnect(struct XenDevice *xendev) 
        blk_unref(blkdev->blk);

        blkdev->blk = NULL;

    }

    xen_be_unbind_evtchn(&blkdev->xendev);

    xen_pv_unbind_evtchn(&blkdev->xendev);



    if (blkdev->sring) {

        xengnttab_unmap(blkdev->xendev.gnttabdev, blkdev->sring, 1);

hw/char/xen_console.c

+16 −14
Original line number Diff line number Diff line
@@ -74,7 +74,7 @@ static void buffer_append(struct XenConsole *con) 


    xen_mb();

    intf->out_cons = cons;

    xen_be_send_notify(&con->xendev);

    xen_pv_send_notify(&con->xendev);



    if (buffer->max_capacity &&

	buffer->size > buffer->max_capacity) {
@@ -142,7 +142,7 @@ static void xencons_receive(void *opaque, const uint8_t *buf, int len) 
    }

    xen_wmb();

    intf->in_prod = prod;

    xen_be_send_notify(&con->xendev);

    xen_pv_send_notify(&con->xendev);

}



static void xencons_send(struct XenConsole *con)
@@ -160,13 +160,14 @@ static void xencons_send(struct XenConsole *con) 
    if (len < 1) {

        if (!con->backlog) {

            con->backlog = 1;

	    xen_be_printf(&con->xendev, 1, "backlog piling up, nobody listening?\n");

            xen_pv_printf(&con->xendev, 1,

                          "backlog piling up, nobody listening?\n");

        }

    } else {

        buffer_advance(&con->buffer, len);

        if (con->backlog && len == size) {

            con->backlog = 0;

	    xen_be_printf(&con->xendev, 1, "backlog is gone\n");

            xen_pv_printf(&con->xendev, 1, "backlog is gone\n");

        }

    }

}
@@ -191,7 +192,7 @@ static int con_init(struct XenDevice *xendev) 


    type = xenstore_read_str(con->console, "type");

    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;

        goto out;

    }
@@ -247,7 +248,8 @@ static int con_initialise(struct XenDevice *xendev) 
    qemu_chr_fe_set_handlers(&con->chr, xencons_can_receive,

                             xencons_receive, NULL, con, NULL, true);



    xen_be_printf(xendev, 1, "ring mfn %d, remote port %d, local port %d, limit %zd\n",

    xen_pv_printf(xendev, 1,

                  "ring mfn %d, remote port %d, local port %d, limit %zd\n",

		  con->ring_ref,

		  con->xendev.remote_port,

		  con->xendev.local_port,
@@ -260,7 +262,7 @@ static void con_disconnect(struct XenDevice *xendev) 
    struct XenConsole *con = container_of(xendev, struct XenConsole, xendev);



    qemu_chr_fe_deinit(&con->chr);

    xen_be_unbind_evtchn(&con->xendev);

    xen_pv_unbind_evtchn(&con->xendev);



    if (con->sring) {

        if (!xendev->dev) {

hw/display/xenfb.c

+69 −58
Original line number Diff line number Diff line
@@ -103,7 +103,8 @@ static int common_bind(struct common *c) 
        return -1;



    xen_be_bind_evtchn(&c->xendev);

    xen_be_printf(&c->xendev, 1, "ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n",

    xen_pv_printf(&c->xendev, 1,

                  "ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n",

                  mfn, c->xendev.remote_port, c->xendev.local_port);



    return 0;
@@ -111,7 +112,7 @@ static int common_bind(struct common *c) 


static void common_unbind(struct common *c)

{

    xen_be_unbind_evtchn(&c->xendev);

    xen_pv_unbind_evtchn(&c->xendev);

    if (c->page) {

        xenforeignmemory_unmap(xen_fmem, c->page, 1);

	c->page = NULL;
@@ -214,7 +215,7 @@ static int xenfb_kbd_event(struct XenInput *xenfb, 
    XENKBD_IN_RING_REF(page, prod) = *event;

    xen_wmb();		/* ensure ring contents visible */

    page->in_prod = prod + 1;

    return xen_be_send_notify(&xenfb->c.xendev);

    return xen_pv_send_notify(&xenfb->c.xendev);

}



/* Send a keyboard (or mouse button) event */
@@ -345,7 +346,7 @@ static int input_initialise(struct XenDevice *xendev) 
    int rc;



    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;

    }
@@ -396,7 +397,7 @@ static void input_event(struct XenDevice *xendev) 
    if (page->out_prod == page->out_cons)

	return;

    page->out_cons = page->out_prod;

    xen_be_send_notify(&xenfb->c.xendev);

    xen_pv_send_notify(&xenfb->c.xendev);

}



/* -------------------------------------------------------------------- */
@@ -510,38 +511,45 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim, 
    int max_width, max_height;



    if (fb_len_lim > fb_len_max) {

	xen_be_printf(&xenfb->c.xendev, 0, "fb size limit %zu exceeds %zu, corrected\n",

        xen_pv_printf(&xenfb->c.xendev, 0,

                      "fb size limit %zu exceeds %zu, corrected\n",

                      fb_len_lim, fb_len_max);

        fb_len_lim = fb_len_max;

    }

    if (fb_len_lim && fb_len > fb_len_lim) {

	xen_be_printf(&xenfb->c.xendev, 0, "frontend fb size %zu limited to %zu\n",

        xen_pv_printf(&xenfb->c.xendev, 0,

                      "frontend fb size %zu limited to %zu\n",

                      fb_len, fb_len_lim);

        fb_len = fb_len_lim;

    }

    if (depth != 8 && depth != 16 && depth != 24 && depth != 32) {

	xen_be_printf(&xenfb->c.xendev, 0, "can't handle frontend fb depth %d\n",

        xen_pv_printf(&xenfb->c.xendev, 0,

                      "can't handle frontend fb depth %d\n",

                      depth);

        return -1;

    }

    if (row_stride <= 0 || row_stride > fb_len) {

	xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", row_stride);

        xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n",

                      row_stride);

        return -1;

    }

    max_width = row_stride / (depth / 8);

    if (width < 0 || width > max_width) {

	xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend width %d limited to %d\n",

        xen_pv_printf(&xenfb->c.xendev, 0,

                      "invalid frontend width %d limited to %d\n",

                      width, max_width);

        width = max_width;

    }

    if (offset < 0 || offset >= fb_len) {

	xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend offset %d (max %zu)\n",

        xen_pv_printf(&xenfb->c.xendev, 0,

                      "invalid frontend offset %d (max %zu)\n",

                      offset, fb_len - 1);

        return -1;

    }

    max_height = (fb_len - offset) / row_stride;

    if (height < 0 || height > max_height) {

	xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend height %d limited to %d\n",

        xen_pv_printf(&xenfb->c.xendev, 0,

                      "invalid frontend height %d limited to %d\n",

                      height, max_height);

        height = max_height;

    }
@@ -553,7 +561,8 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim, 
    xenfb->offset = offset;

    xenfb->up_fullscreen = 1;

    xenfb->do_resize = 1;

    xen_be_printf(&xenfb->c.xendev, 1, "framebuffer %dx%dx%d offset %d stride %d\n",

    xen_pv_printf(&xenfb->c.xendev, 1,

                  "framebuffer %dx%dx%d offset %d stride %d\n",

                  width, height, depth, offset, row_stride);

    return 0;

}
@@ -631,7 +640,7 @@ static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h) 
	}

    }

    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);



    dpy_gfx_update(xenfb->c.con, x, y, w, h);
@@ -663,7 +672,7 @@ static void xenfb_send_event(struct XenFB *xenfb, union xenfb_in_event *event) 
    xen_wmb();                  /* ensure ring contents visible */

    page->in_prod = prod + 1;



    xen_be_send_notify(&xenfb->c.xendev);

    xen_pv_send_notify(&xenfb->c.xendev);

}



static void xenfb_send_refresh_period(struct XenFB *xenfb, int period)
@@ -721,7 +730,8 @@ static void xenfb_update(void *opaque) 
            break;

        }

        dpy_gfx_replace_surface(xenfb->c.con, surface);

        xen_be_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n",

        xen_pv_printf(&xenfb->c.xendev, 1,

                      "update: resizing: %dx%d @ %d bpp%s\n",

                      xenfb->width, xenfb->height, xenfb->depth,

                      is_buffer_shared(surface) ? " (shared)" : "");

        xenfb->up_fullscreen = 1;
@@ -729,10 +739,11 @@ static void xenfb_update(void *opaque) 


    /* run queued updates */

    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);

    } else if (xenfb->up_count) {

	xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count);

        xen_pv_printf(&xenfb->c.xendev, 3, "update: %d rects\n",

                      xenfb->up_count);

        for (i = 0; i < xenfb->up_count; i++)

            xenfb_guest_copy(xenfb,

                             xenfb->up_rects[i].x,
@@ -740,7 +751,7 @@ static void xenfb_update(void *opaque) 
                             xenfb->up_rects[i].w,

                             xenfb->up_rects[i].h);

    } 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_fullscreen = 0;
@@ -794,14 +805,14 @@ static void xenfb_handle_events(struct XenFB *xenfb) 
	    w = MIN(event->update.width, xenfb->width - x);

	    h = MIN(event->update.height, xenfb->height - y);

	    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;

	    }

	    if (x != event->update.x ||

                y != event->update.y ||

		w != event->update.width ||

		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) {

		/* scroll detector: updated more than 50% of the lines,
@@ -883,7 +894,7 @@ static int fb_initialise(struct XenDevice *xendev) 
    if (fb->feature_update)

	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);

    return 0;

}
@@ -902,7 +913,7 @@ static void fb_disconnect(struct XenDevice *xendev) 
                      PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON,

                      -1, 0);

    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",

                errno);

    }
@@ -923,7 +934,7 @@ static void fb_frontend_changed(struct XenDevice *xendev, const char *node) 
    if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 &&

        xendev->fe_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);

        fb->bug_trigger = 1; /* only once */

    }
@@ -934,7 +945,7 @@ static void fb_event(struct XenDevice *xendev) 
    struct XenFB *xenfb = container_of(xendev, struct XenFB, c.xendev);



    xenfb_handle_events(xenfb);

    xen_be_send_notify(&xenfb->c.xendev);

    xen_pv_send_notify(&xenfb->c.xendev);

}



/* -------------------------------------------------------------------- */
@@ -977,14 +988,14 @@ void xen_init_display(int domid) 
wait_more:

    i++;

    main_loop_wait(true);

    xfb = xen_be_find_xendev("vfb", domid, 0);

    xin = xen_be_find_xendev("vkbd", domid, 0);

    xfb = xen_pv_find_xendev("vfb", domid, 0);

    xin = xen_pv_find_xendev("vkbd", domid, 0);

    if (!xfb || !xin) {

        if (i < 256) {

            usleep(10000);

            goto wait_more;

        }

        xen_be_printf(NULL, 1, "displaystate setup failed\n");

        xen_pv_printf(NULL, 1, "displaystate setup failed\n");

        return;

    }

hw/net/xen_nic.c

+21 −15
Original line number Diff line number Diff line
@@ -69,7 +69,7 @@ static void net_tx_response(struct XenNetDev *netdev, netif_tx_request_t *txp, i 
    netdev->tx_ring.rsp_prod_pvt = ++i;

    RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->tx_ring, notify);

    if (notify) {

        xen_be_send_notify(&netdev->xendev);

        xen_pv_send_notify(&netdev->xendev);

    }



    if (i == netdev->tx_ring.req_cons) {
@@ -128,30 +128,32 @@ static void net_tx_packets(struct XenNetDev *netdev) 
            /* should not happen in theory, we don't announce the *

             * feature-{sg,gso,whatelse} flags in xenstore (yet?) */

            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);

                continue;

            }

            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);

                continue;

            }

#endif



            if (txreq.size < 14) {

                xen_be_printf(&netdev->xendev, 0, "bad packet size: %d\n", txreq.size);

                xen_pv_printf(&netdev->xendev, 0, "bad packet size: %d\n",

                              txreq.size);

                net_tx_error(netdev, &txreq, rc);

                continue;

            }



            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);

                continue;

            }



            xen_be_printf(&netdev->xendev, 3, "tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n",

            xen_pv_printf(&netdev->xendev, 3,

                          "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.flags & NETTXF_csum_blank)     ? " csum_blank"     : "",

                          (txreq.flags & NETTXF_data_validated) ? " data_validated" : "",
@@ -162,7 +164,8 @@ static void net_tx_packets(struct XenNetDev *netdev) 
                                           netdev->xendev.dom,

                                           txreq.gref, PROT_READ);

            if (page == NULL) {

                xen_be_printf(&netdev->xendev, 0, "error: tx gref dereference failed (%d)\n",

                xen_pv_printf(&netdev->xendev, 0,

                              "error: tx gref dereference failed (%d)\n",

                             txreq.gref);

                net_tx_error(netdev, &txreq, rc);

                continue;
@@ -211,13 +214,14 @@ static void net_rx_response(struct XenNetDev *netdev, 
        resp->status = (int16_t)st;

    }



    xen_be_printf(&netdev->xendev, 3, "rx response: idx %d, status %d, flags 0x%x\n",

    xen_pv_printf(&netdev->xendev, 3,

                  "rx response: idx %d, status %d, flags 0x%x\n",

                  i, resp->status, resp->flags);



    netdev->rx_ring.rsp_prod_pvt = ++i;

    RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->rx_ring, notify);

    if (notify) {

        xen_be_send_notify(&netdev->xendev);

        xen_pv_send_notify(&netdev->xendev);

    }

}
@@ -242,7 +246,7 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size 
        return 0;

    }

    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);

        return -1;

    }
@@ -254,7 +258,8 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size 
                                   netdev->xendev.dom,

                                   rxreq.gref, PROT_WRITE);

    if (page == NULL) {

        xen_be_printf(&netdev->xendev, 0, "error: rx gref dereference failed (%d)\n",

        xen_pv_printf(&netdev->xendev, 0,

                      "error: rx gref dereference failed (%d)\n",

                      rxreq.gref);

        net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0);

        return -1;
@@ -328,7 +333,8 @@ static int net_connect(struct XenDevice *xendev) 
        rx_copy = 0;

    }

    if (rx_copy == 0) {

        xen_be_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n");

        xen_pv_printf(&netdev->xendev, 0,

                      "frontend doesn't support rx-copy.\n");

        return -1;

    }
@@ -353,7 +359,7 @@ static int net_connect(struct XenDevice *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",

                  netdev->tx_ring_ref, netdev->rx_ring_ref,

                  netdev->xendev.remote_port, netdev->xendev.local_port);
@@ -366,7 +372,7 @@ static void net_disconnect(struct XenDevice *xendev) 
{

    struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);



    xen_be_unbind_evtchn(&netdev->xendev);

    xen_pv_unbind_evtchn(&netdev->xendev);



    if (netdev->txs) {

        xengnttab_unmap(netdev->xendev.gnttabdev, netdev->txs, 1);

hw/usb/xen-usb.c

+23 −23

File changed.

Preview size limit exceeded, changes collapsed.