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:
parent
67b724e69e
commit
209cd7abe2
129
hw/xen_backend.c
129
hw/xen_backend.c
|
@ -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
114
hw/xen_disk.c
|
@ -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
57
hw/xen_nic.c
|
@ -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);
|
||||
|
||||
|
|
Loading…
Reference in New Issue