OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

xen: Replace some tab-indents with spaces (clean-up). 

And put braces for blocks with a single statement.

Signed-off-by: Anthony PERARD <anthony.perard@citrix.com>
Acked-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Alexander Graf <agraf@suse.de>
This commit is contained in:
Anthony PERARD 2010-09-23 12:28:45 +01:00 committed by Alexander Graf
parent 67b724e69e
commit 209cd7abe2
3 changed files with 626 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
hw/xen_backend.c
View File

@ -58,8 +58,9 @@ int xenstore_write_str(const char *base, const char *node, const char *val)
char abspath[XEN_BUFSIZE];
snprintf(abspath, sizeof(abspath), "%s/%s", base, node);
if (!xs_write(xenstore, 0, abspath, val, strlen(val)))
if (!xs_write(xenstore, 0, abspath, val, strlen(val))) {
return -1;
}
return 0;
}
@ -94,8 +95,9 @@ int xenstore_read_int(const char *base, const char *node, int *ival)
int rc = -1;
val = xenstore_read_str(base, node);
if (val && 1 == sscanf(val, "%d", ival))
if (val && 1 == sscanf(val, "%d", ival)) {
rc = 0;
}
qemu_free(val);
return rc;
}
@ -151,8 +153,9 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
int rc;
rc = xenstore_write_be_int(xendev, "state", state);
if (rc < 0)
if (rc < 0) {
return rc;
}
xen_be_printf(xendev, 1, "backend state: %s -> %s\n",
xenbus_strstate(xendev->be_state), xenbus_strstate(state));
xendev->be_state = state;
@ -166,12 +169,15 @@ struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev)
struct XenDevice *xendev;
QTAILQ_FOREACH(xendev, &xendevs, next) {
if (xendev->dom != dom)
if (xendev->dom != dom) {
continue;
if (xendev->dev != dev)
}
if (xendev->dev != dev) {
continue;
if (strcmp(xendev->type, type) != 0)
}
if (strcmp(xendev->type, type) != 0) {
continue;
}
return xendev;
}
return NULL;
@ -187,8 +193,9 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
char *dom0;
xendev = xen_be_find_xendev(type, dom, dev);
if (xendev)
if (xendev) {
return xendev;
}
/* init new xendev */
xendev = qemu_mallocz(ops->size);
@ -229,8 +236,9 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
QTAILQ_INSERT_TAIL(&xendevs, xendev, next);
if (xendev->ops->alloc)
if (xendev->ops->alloc) {
xendev->ops->alloc(xendev);
}
return xendev;
}
@ -251,13 +259,16 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev)
xendev = xnext;
xnext = xendev->next.tqe_next;
if (xendev->dom != dom)
if (xendev->dom != dom) {
continue;
if (xendev->dev != dev && dev != -1)
}
if (xendev->dev != dev && dev != -1) {
continue;
}
if (xendev->ops->free)
if (xendev->ops->free) {
xendev->ops->free(xendev);
}
if (xendev->fe) {
char token[XEN_BUFSIZE];
@ -266,10 +277,12 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev)
qemu_free(xendev->fe);
}
if (xendev->evtchndev >= 0)
if (xendev->evtchndev >= 0) {
xc_evtchn_close(xendev->evtchndev);
if (xendev->gnttabdev >= 0)
}
if (xendev->gnttabdev >= 0) {
xc_gnttab_close(xendev->gnttabdev);
}
QTAILQ_REMOVE(&xendevs, xendev, next);
qemu_free(xendev);
@ -285,43 +298,49 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev)
static void xen_be_backend_changed(struct XenDevice *xendev, const char *node)
{
if (node == NULL || strcmp(node, "online") == 0) {
if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1)
if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1) {
xendev->online = 0;
}
}
if (node) {
xen_be_printf(xendev, 2, "backend update: %s\n", node);
if (xendev->ops->backend_changed)
if (xendev->ops->backend_changed) {
xendev->ops->backend_changed(xendev, node);
}
}
}
static void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
{
int fe_state;
if (node == NULL || strcmp(node, "state") == 0) {
if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1)
if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
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",
xenbus_strstate(xendev->fe_state),
xenbus_strstate(fe_state));
}
xendev->fe_state = fe_state;
}
if (node == NULL || strcmp(node, "protocol") == 0) {
qemu_free(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", xendev->protocol);
}
}
if (node) {
xen_be_printf(xendev, 2, "frontend update: %s\n", node);
if (xendev->ops->frontend_changed)
if (xendev->ops->frontend_changed) {
xendev->ops->frontend_changed(xendev, node);
}
}
}
/* ------------------------------------------------------------- */
/* Check for possible state transitions and perform them. */
@ -387,8 +406,9 @@ static int xen_be_try_init(struct XenDevice *xendev)
return -1;
}
if (xendev->ops->init)
if (xendev->ops->init) {
rc = xendev->ops->init(xendev);
}
if (rc != 0) {
xen_be_printf(xendev, 1, "init() failed\n");
return rc;
@ -420,8 +440,9 @@ static int xen_be_try_connect(struct XenDevice *xendev)
}
}
if (xendev->ops->connect)
if (xendev->ops->connect) {
rc = xendev->ops->connect(xendev);
}
if (rc != 0) {
xen_be_printf(xendev, 0, "connect() failed\n");
return rc;
@ -440,19 +461,22 @@ static void xen_be_disconnect(struct XenDevice *xendev, enum xenbus_state state)
{
if (xendev->be_state != XenbusStateClosing &&
xendev->be_state != XenbusStateClosed &&
xendev->ops->disconnect)
xendev->ops->disconnect) {
xendev->ops->disconnect(xendev);
if (xendev->be_state != state)
}
if (xendev->be_state != state) {
xen_be_set_state(xendev, state);
}
}
/*
* Try to reset xendev, for reconnection by another frontend instance.
*/
static int xen_be_try_reset(struct XenDevice *xendev)
{
if (xendev->fe_state != XenbusStateInitialising)
if (xendev->fe_state != XenbusStateInitialising) {
return -1;
}
xen_be_printf(xendev, 1, "device reset (for re-connect)\n");
xen_be_set_state(xendev, XenbusStateInitialising);
@ -491,10 +515,11 @@ void xen_be_check_state(struct XenDevice *xendev)
default:
rc = -1;
}
if (rc != 0)
if (rc != 0) {
break;
}
}
}
/* ------------------------------------------------------------- */
@ -517,12 +542,14 @@ static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
/* look for backends */
dev = xs_directory(xenstore, 0, path, &cdev);
if (!dev)
if (!dev) {
return 0;
}
for (j = 0; j < cdev; j++) {
xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops);
if (xendev == NULL)
if (xendev == NULL) {
continue;
}
xen_be_check_state(xendev);
}
free(dev);
@ -539,15 +566,18 @@ static void xenstore_update_be(char *watch, char *type, int dom,
dom0 = xs_get_domain_path(xenstore, 0);
len = snprintf(path, sizeof(path), "%s/backend/%s/%d", dom0, type, dom);
free(dom0);
if (strncmp(path, watch, len) != 0)
if (strncmp(path, watch, len) != 0) {
return;
}
if (sscanf(watch+len, "/%u/%255s", &dev, path) != 2) {
strcpy(path, "");
if (sscanf(watch+len, "/%u", &dev) != 1)
if (sscanf(watch+len, "/%u", &dev) != 1) {
dev = -1;
}
if (dev == -1)
}
if (dev == -1) {
return;
}
if (0) {
/* FIXME: detect devices being deleted from xenstore ... */
@ -567,10 +597,12 @@ static void xenstore_update_fe(char *watch, struct XenDevice *xendev)
unsigned int len;
len = strlen(xendev->fe);
if (strncmp(xendev->fe, watch, len) != 0)
if (strncmp(xendev->fe, watch, len) != 0) {
return;
if (watch[len] != '/')
}
if (watch[len] != '/') {
return;
}
node = watch + len + 1;
xen_be_frontend_changed(xendev, node);
@ -584,14 +616,17 @@ static void xenstore_update(void *unused)
unsigned int dom, count;
vec = xs_read_watch(xenstore, &count);
if (vec == NULL)
if (vec == NULL) {
goto cleanup;
}
if (sscanf(vec[XS_WATCH_TOKEN], "be:%" PRIxPTR ":%d:%" PRIxPTR,
&type, &dom, &ops) == 3)
&type, &dom, &ops) == 3) {
xenstore_update_be(vec[XS_WATCH_PATH], (void*)type, dom, (void*)ops);
if (sscanf(vec[XS_WATCH_TOKEN], "fe:%" PRIxPTR, &ptr) == 1)
}
if (sscanf(vec[XS_WATCH_TOKEN], "fe:%" PRIxPTR, &ptr) == 1) {
xenstore_update_fe(vec[XS_WATCH_PATH], (void*)ptr);
}
cleanup:
free(vec);
@ -610,9 +645,10 @@ static void xen_be_evtchn_event(void *opaque)
}
xc_evtchn_unmask(xendev->evtchndev, port);
if (xendev->ops->event)
if (xendev->ops->event) {
xendev->ops->event(xendev);
}
}
/* -------------------------------------------------------------------- */
@ -624,8 +660,9 @@ int xen_be_init(void)
return -1;
}
if (qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL) < 0)
if (qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL) < 0) {
goto err;
}
xen_xc = xc_interface_open();
if (xen_xc == -1) {
@ -649,8 +686,9 @@ int xen_be_register(const char *type, struct XenDevOps *ops)
int xen_be_bind_evtchn(struct XenDevice *xendev)
{
if (xendev->local_port != -1)
if (xendev->local_port != -1) {
return 0;
}
xendev->local_port = xc_evtchn_bind_interdomain
(xendev->evtchndev, xendev->dom, xendev->remote_port);
if (xendev->local_port == -1) {
@ -665,8 +703,9 @@ int xen_be_bind_evtchn(struct XenDevice *xendev)
void xen_be_unbind_evtchn(struct XenDevice *xendev)
{
if (xendev->local_port == -1)
if (xendev->local_port == -1) {
return;
}
qemu_set_fd_handler(xc_evtchn_fd(xendev->evtchndev), NULL, NULL, NULL);
xc_evtchn_unbind(xendev->evtchndev, xendev->local_port);
xen_be_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port);
@ -690,18 +729,22 @@ void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...
va_list args;
if (xendev) {
if (msg_level > xendev->debug)
if (msg_level > xendev->debug) {
return;
}
qemu_log("xen be: %s: ", xendev->name);
if (msg_level == 0)
if (msg_level == 0) {
fprintf(stderr, "xen be: %s: ", xendev->name);
}
} else {
if (msg_level > debug)
if (msg_level > debug) {
return;
}
qemu_log("xen be core: ");
if (msg_level == 0)
if (msg_level == 0) {
fprintf(stderr, "xen be core: ");
}
}
va_start(args, fmt);
qemu_log_vprintf(fmt, args);
va_end(args);

114
hw/xen_disk.c
View File

@ -120,8 +120,9 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev)
struct ioreq *ioreq = NULL;
if (QLIST_EMPTY(&blkdev->freelist)) {
if (blkdev->requests_total >= max_requests)
if (blkdev->requests_total >= max_requests) {
goto out;
}
/* allocate new struct */
ioreq = qemu_mallocz(sizeof(*ioreq));
ioreq->blkdev = blkdev;
@ -185,13 +186,15 @@ static int ioreq_parse(struct ioreq *ioreq)
ioreq->presync = 1;
return 0;
}
if (!syncwrite)
if (!syncwrite) {
ioreq->presync = ioreq->postsync = 1;
}
/* fall through */
case BLKIF_OP_WRITE:
ioreq->prot = PROT_READ; /* from memory */
if (syncwrite)
if (syncwrite) {
ioreq->postsync = 1;
}
break;
default:
xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n",
@ -242,23 +245,28 @@ static void ioreq_unmap(struct ioreq *ioreq)
int gnt = ioreq->blkdev->xendev.gnttabdev;
int i;
if (ioreq->v.niov == 0)
if (ioreq->v.niov == 0) {
return;
}
if (batch_maps) {
if (!ioreq->pages)
if (!ioreq->pages) {
return;
if (xc_gnttab_munmap(gnt, ioreq->pages, ioreq->v.niov) != 0)
}
if (xc_gnttab_munmap(gnt, ioreq->pages, ioreq->v.niov) != 0) {
xen_be_printf(&ioreq->blkdev->xendev, 0, "xc_gnttab_munmap failed: %s\n",
strerror(errno));
}
ioreq->blkdev->cnt_map -= ioreq->v.niov;
ioreq->pages = NULL;
} else {
for (i = 0; i < ioreq->v.niov; i++) {
if (!ioreq->page[i])
if (!ioreq->page[i]) {
continue;
if (xc_gnttab_munmap(gnt, ioreq->page[i], 1) != 0)
}
if (xc_gnttab_munmap(gnt, ioreq->page[i], 1) != 0) {
xen_be_printf(&ioreq->blkdev->xendev, 0, "xc_gnttab_munmap failed: %s\n",
strerror(errno));
}
ioreq->blkdev->cnt_map--;
ioreq->page[i] = NULL;
}
@ -270,8 +278,9 @@ static int ioreq_map(struct ioreq *ioreq)
int gnt = ioreq->blkdev->xendev.gnttabdev;
int i;
if (ioreq->v.niov == 0)
if (ioreq->v.niov == 0) {
return 0;
}
if (batch_maps) {
ioreq->pages = xc_gnttab_map_grant_refs
(gnt, ioreq->v.niov, ioreq->domids, ioreq->refs, ioreq->prot);
@ -281,9 +290,10 @@ static int ioreq_map(struct ioreq *ioreq)
ioreq->v.niov, strerror(errno), ioreq->blkdev->cnt_map);
return -1;
}
for (i = 0; i < ioreq->v.niov; i++)
for (i = 0; i < ioreq->v.niov; i++) {
ioreq->v.iov[i].iov_base = ioreq->pages + i * XC_PAGE_SIZE +
(uintptr_t)ioreq->v.iov[i].iov_base;
}
ioreq->blkdev->cnt_map += ioreq->v.niov;
} else {
for (i = 0; i < ioreq->v.niov; i++) {
@ -309,10 +319,12 @@ static int ioreq_runio_qemu_sync(struct ioreq *ioreq)
int i, rc, len = 0;
off_t pos;
if (ioreq->req.nr_segments && ioreq_map(ioreq) == -1)
if (ioreq->req.nr_segments && ioreq_map(ioreq) == -1) {
goto err_no_map;
if (ioreq->presync)
}
if (ioreq->presync) {
bdrv_flush(blkdev->bs);
}
switch (ioreq->req.operation) {
case BLKIF_OP_READ:
@ -333,8 +345,9 @@ static int ioreq_runio_qemu_sync(struct ioreq *ioreq)
break;
case BLKIF_OP_WRITE:
case BLKIF_OP_WRITE_BARRIER:
if (!ioreq->req.nr_segments)
if (!ioreq->req.nr_segments) {
break;
}
pos = ioreq->start;
for (i = 0; i < ioreq->v.niov; i++) {
rc = bdrv_write(blkdev->bs, pos / BLOCK_SIZE,
@ -355,8 +368,9 @@ static int ioreq_runio_qemu_sync(struct ioreq *ioreq)
goto err;
}
if (ioreq->postsync)
if (ioreq->postsync) {
bdrv_flush(blkdev->bs);
}
ioreq->status = BLKIF_RSP_OKAY;
ioreq_unmap(ioreq);
@ -382,8 +396,9 @@ static void qemu_aio_complete(void *opaque, int ret)
}
ioreq->aio_inflight--;
if (ioreq->aio_inflight > 0)
if (ioreq->aio_inflight > 0) {
return;
}
ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY;
ioreq_unmap(ioreq);
@ -395,12 +410,14 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq)
{
struct XenBlkDev *blkdev = ioreq->blkdev;
if (ioreq->req.nr_segments && ioreq_map(ioreq) == -1)
if (ioreq->req.nr_segments && ioreq_map(ioreq) == -1) {
goto err_no_map;
}
ioreq->aio_inflight++;
if (ioreq->presync)
if (ioreq->presync) {
bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */
}
switch (ioreq->req.operation) {
case BLKIF_OP_READ:
@ -411,8 +428,9 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq)
break;
case BLKIF_OP_WRITE:
case BLKIF_OP_WRITE_BARRIER:
if (!ioreq->req.nr_segments)
if (!ioreq->req.nr_segments) {
break;
}
ioreq->aio_inflight++;
bdrv_aio_writev(blkdev->bs, ioreq->start / BLOCK_SIZE,
&ioreq->v, ioreq->v.size / BLOCK_SIZE,
@ -423,8 +441,9 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq)
goto err;
}
if (ioreq->postsync)
if (ioreq->postsync) {
bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */
}
qemu_aio_complete(ioreq, 0);
return 0;
@ -480,8 +499,9 @@ static int blk_send_response_one(struct ioreq *ioreq)
have_requests = 1;
}
if (have_requests)
if (have_requests) {
blkdev->more_work++;
}
return send_notify;
}
@ -496,9 +516,10 @@ static void blk_send_response_all(struct XenBlkDev *blkdev)
send_notify += blk_send_response_one(ioreq);
ioreq_release(ioreq);
}
if (send_notify)
if (send_notify) {
xen_be_send_notify(&blkdev->xendev);
}
}
static int blk_get_request(struct XenBlkDev *blkdev, struct ioreq *ioreq, RING_IDX rc)
{
@ -530,12 +551,14 @@ static void blk_handle_requests(struct XenBlkDev *blkdev)
rp = blkdev->rings.common.sring->req_prod;
xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
if (use_aio)
if (use_aio) {
blk_send_response_all(blkdev);
}
while (rc != rp) {
/* pull request from ring */
if (RING_REQUEST_CONS_OVERFLOW(&blkdev->rings.common, rc))
if (RING_REQUEST_CONS_OVERFLOW(&blkdev->rings.common, rc)) {
break;
}
ioreq = ioreq_start(blkdev);
if (ioreq == NULL) {
blkdev->more_work++;
@ -546,8 +569,9 @@ static void blk_handle_requests(struct XenBlkDev *blkdev)
/* parse them */
if (ioreq_parse(ioreq) != 0) {
if (blk_send_response_one(ioreq))
if (blk_send_response_one(ioreq)) {
xen_be_send_notify(&blkdev->xendev);
}
ioreq_release(ioreq);
continue;
}
@ -560,12 +584,14 @@ static void blk_handle_requests(struct XenBlkDev *blkdev)
ioreq_runio_qemu_sync(ioreq);
}
}
if (!use_aio)
if (!use_aio) {
blk_send_response_all(blkdev);
}
if (blkdev->more_work && blkdev->requests_inflight < max_requests)
if (blkdev->more_work && blkdev->requests_inflight < max_requests) {
qemu_bh_schedule(blkdev->bh);
}
}
/* ------------------------------------------------------------- */
@ -583,9 +609,10 @@ static void blk_alloc(struct XenDevice *xendev)
QLIST_INIT(&blkdev->finished);
QLIST_INIT(&blkdev->freelist);
blkdev->bh = qemu_bh_new(blk_bh, blkdev);
if (xen_mode != XEN_EMULATE)
if (xen_mode != XEN_EMULATE) {
batch_maps = 1;
}
}
static int blk_init(struct XenDevice *xendev)
{
@ -606,21 +633,26 @@ static int blk_init(struct XenDevice *xendev)
blkdev->filename = blkdev->params;
}
}
if (blkdev->mode == NULL)
if (blkdev->mode == NULL) {
blkdev->mode = xenstore_read_be_str(&blkdev->xendev, "mode");
if (blkdev->type == NULL)
}
if (blkdev->type == NULL) {
blkdev->type = xenstore_read_be_str(&blkdev->xendev, "type");
if (blkdev->dev == NULL)
}
if (blkdev->dev == NULL) {
blkdev->dev = xenstore_read_be_str(&blkdev->xendev, "dev");
if (blkdev->devtype == NULL)
}
if (blkdev->devtype == NULL) {
blkdev->devtype = xenstore_read_be_str(&blkdev->xendev, "device-type");
}
/* do we have all we need? */
if (blkdev->params == NULL ||
blkdev->mode == NULL ||
blkdev->type == NULL ||
blkdev->dev == NULL)
blkdev->dev == NULL) {
return -1;
}
/* read-only ? */
if (strcmp(blkdev->mode, "w") == 0) {
@ -631,8 +663,9 @@ static int blk_init(struct XenDevice *xendev)
}
/* cdrom ? */
if (blkdev->devtype && !strcmp(blkdev->devtype, "cdrom"))
if (blkdev->devtype && !strcmp(blkdev->devtype, "cdrom")) {
info |= VDISK_CDROM;
}
/* init qemu block driver */
index = (blkdev->xendev.dev - 202 * 256) / 16;
@ -679,26 +712,31 @@ static int blk_connect(struct XenDevice *xendev)
{
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
if (xenstore_read_fe_int(&blkdev->xendev, "ring-ref", &blkdev->ring_ref) == -1)
if (xenstore_read_fe_int(&blkdev->xendev, "ring-ref", &blkdev->ring_ref) == -1) {
return -1;
}
if (xenstore_read_fe_int(&blkdev->xendev, "event-channel",
&blkdev->xendev.remote_port) == -1)
&blkdev->xendev.remote_port) == -1) {
return -1;
}
blkdev->protocol = BLKIF_PROTOCOL_NATIVE;
if (blkdev->xendev.protocol) {
if (strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_32) == 0)
if (strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_32) == 0) {
blkdev->protocol = BLKIF_PROTOCOL_X86_32;
if (strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_64) == 0)
}
if (strcmp(blkdev->xendev.protocol, XEN_IO_PROTO_ABI_X86_64) == 0) {
blkdev->protocol = BLKIF_PROTOCOL_X86_64;
}
}
blkdev->sring = xc_gnttab_map_grant_ref(blkdev->xendev.gnttabdev,
blkdev->xendev.dom,
blkdev->ring_ref,
PROT_READ | PROT_WRITE);
if (!blkdev->sring)
if (!blkdev->sring) {
return -1;
}
blkdev->cnt_map++;
switch (blkdev->protocol) {

57
hw/xen_nic.c
View File

@ -74,22 +74,25 @@ static void net_tx_response(struct XenNetDev *netdev, netif_tx_request_t *txp, i
resp->status = st;
#if 0
if (txp->flags & NETTXF_extra_info)
if (txp->flags & NETTXF_extra_info) {
RING_GET_RESPONSE(&netdev->tx_ring, ++i)->status = NETIF_RSP_NULL;
}
#endif
netdev->tx_ring.rsp_prod_pvt = ++i;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->tx_ring, notify);
if (notify)
if (notify) {
xen_be_send_notify(&netdev->xendev);
}
if (i == netdev->tx_ring.req_cons) {
int more_to_do;
RING_FINAL_CHECK_FOR_REQUESTS(&netdev->tx_ring, more_to_do);
if (more_to_do)
if (more_to_do) {
netdev->tx_work++;
}
}
}
static void net_tx_error(struct XenNetDev *netdev, netif_tx_request_t *txp, RING_IDX end)
{
@ -102,8 +105,9 @@ static void net_tx_error(struct XenNetDev *netdev, netif_tx_request_t *txp, RING
do {
make_tx_response(netif, txp, NETIF_RSP_ERROR);
if (cons >= end)
if (cons >= end) {
break;
}
txp = RING_GET_REQUEST(&netdev->tx_ring, cons++);
} while (1);
netdev->tx_ring.req_cons = cons;
@ -127,8 +131,9 @@ static void net_tx_packets(struct XenNetDev *netdev)
xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
while ((rc != rp)) {
if (RING_REQUEST_CONS_OVERFLOW(&netdev->tx_ring, rc))
if (RING_REQUEST_CONS_OVERFLOW(&netdev->tx_ring, rc)) {
break;
}
memcpy(&txreq, RING_GET_REQUEST(&netdev->tx_ring, rc), sizeof(txreq));
netdev->tx_ring.req_cons = ++rc;
@ -177,8 +182,9 @@ static void net_tx_packets(struct XenNetDev *netdev)
}
if (txreq.flags & NETTXF_csum_blank) {
/* have read-only mapping -> can't fill checksum in-place */
if (!tmpbuf)
if (!tmpbuf) {
tmpbuf = qemu_malloc(XC_PAGE_SIZE);
}
memcpy(tmpbuf, page + txreq.offset, txreq.size);
net_checksum_calculate(tmpbuf, txreq.size);
qemu_send_packet(&netdev->nic->nc, tmpbuf, txreq.size);
@ -188,8 +194,9 @@ static void net_tx_packets(struct XenNetDev *netdev)
xc_gnttab_munmap(netdev->xendev.gnttabdev, page, 1);
net_tx_response(netdev, &txreq, NETIF_RSP_OKAY);
}
if (!netdev->tx_work)
if (!netdev->tx_work) {
break;
}
netdev->tx_work = 0;
}
qemu_free(tmpbuf);
@ -211,17 +218,19 @@ static void net_rx_response(struct XenNetDev *netdev,
resp->flags = flags;
resp->id = req->id;
resp->status = (int16_t)size;
if (st < 0)
if (st < 0) {
resp->status = (int16_t)st;
}
xen_be_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)
if (notify) {
xen_be_send_notify(&netdev->xendev);
}
}
#define NET_IP_ALIGN 2
@ -230,8 +239,9 @@ static int net_rx_ok(VLANClientState *nc)
struct XenNetDev *netdev = DO_UPCAST(NICState, nc, nc)->opaque;
RING_IDX rc, rp;
if (netdev->xendev.be_state != XenbusStateConnected)
if (netdev->xendev.be_state != XenbusStateConnected) {
return 0;
}
rc = netdev->rx_ring.req_cons;
rp = netdev->rx_ring.sring->req_prod;
@ -252,8 +262,9 @@ static ssize_t net_rx_packet(VLANClientState *nc, const uint8_t *buf, size_t siz
RING_IDX rc, rp;
void *page;
if (netdev->xendev.be_state != XenbusStateConnected)
if (netdev->xendev.be_state != XenbusStateConnected) {
return -1;
}
rc = netdev->rx_ring.req_cons;
rp = netdev->rx_ring.sring->req_prod;
@ -302,15 +313,18 @@ static int net_init(struct XenDevice *xendev)
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
/* read xenstore entries */
if (netdev->mac == NULL)
if (netdev->mac == NULL) {
netdev->mac = xenstore_read_be_str(&netdev->xendev, "mac");
}
/* do we have all we need? */
if (netdev->mac == NULL)
if (netdev->mac == NULL) {
return -1;
}
if (net_parse_macaddr(netdev->conf.macaddr.a, netdev->mac) < 0)
if (net_parse_macaddr(netdev->conf.macaddr.a, netdev->mac) < 0) {
return -1;
}
netdev->conf.vlan = qemu_find_vlan(netdev->xendev.dev, 1);
netdev->conf.peer = NULL;
@ -334,17 +348,21 @@ static int net_connect(struct XenDevice *xendev)
int rx_copy;
if (xenstore_read_fe_int(&netdev->xendev, "tx-ring-ref",
&netdev->tx_ring_ref) == -1)
&netdev->tx_ring_ref) == -1) {
return -1;
}
if (xenstore_read_fe_int(&netdev->xendev, "rx-ring-ref",
&netdev->rx_ring_ref) == -1)
&netdev->rx_ring_ref) == -1) {
return 1;
}
if (xenstore_read_fe_int(&netdev->xendev, "event-channel",
&netdev->xendev.remote_port) == -1)
&netdev->xendev.remote_port) == -1) {
return -1;
}
if (xenstore_read_fe_int(&netdev->xendev, "request-rx-copy", &rx_copy) == -1)
if (xenstore_read_fe_int(&netdev->xendev, "request-rx-copy", &rx_copy) == -1) {
rx_copy = 0;
}
if (rx_copy == 0) {
xen_be_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n");
return -1;
@ -358,8 +376,9 @@ static int net_connect(struct XenDevice *xendev)
netdev->xendev.dom,
netdev->rx_ring_ref,
PROT_READ | PROT_WRITE);
if (!netdev->txs || !netdev->rxs)
if (!netdev->txs || !netdev->rxs) {
return -1;
}
BACK_RING_INIT(&netdev->tx_ring, netdev->txs, XC_PAGE_SIZE);
BACK_RING_INIT(&netdev->rx_ring, netdev->rxs, XC_PAGE_SIZE);