From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from [140.186.70.92] (port=36425 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1PsdkS-0001FX-GS for qemu-devel@nongnu.org; Thu, 24 Feb 2011 11:09:04 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1PsdkO-0007EL-8V for qemu-devel@nongnu.org; Thu, 24 Feb 2011 11:09:00 -0500 Received: from mail-vx0-f173.google.com ([209.85.220.173]:53082) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1PsdkO-0007EF-10 for qemu-devel@nongnu.org; Thu, 24 Feb 2011 11:08:56 -0500 Received: by vxb41 with SMTP id 41so605080vxb.4 for ; Thu, 24 Feb 2011 08:08:55 -0800 (PST) Message-ID: <4D66820A.4090401@codemonkey.ws> Date: Thu, 24 Feb 2011 10:06:34 -0600 From: Anthony Liguori MIME-Version: 1.0 Subject: Re: [Qemu-devel] [PATCH V10 01/15] xen: Replace some tab-indents with spaces (clean-up). References: <1296658172-16609-1-git-send-email-anthony.perard@citrix.com> <1296658172-16609-2-git-send-email-anthony.perard@citrix.com> In-Reply-To: <1296658172-16609-2-git-send-email-anthony.perard@citrix.com> Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: anthony.perard@citrix.com Cc: Xen Devel , QEMU-devel , Stefano Stabellini On 02/02/2011 08:49 AM, anthony.perard@citrix.com wrote: > From: Anthony PERARD > > Signed-off-by: Anthony PERARD > Acked-by: Alexander Graf > --- > hw/xen_backend.c | 308 +++++++++++++++++++++--------------------- > hw/xen_disk.c | 394 +++++++++++++++++++++++++++--------------------------- > hw/xen_nic.c | 222 +++++++++++++++--------------- > 3 files changed, 462 insertions(+), 462 deletions(-) > > diff --git a/hw/xen_backend.c b/hw/xen_backend.c > index a2e408f..860b038 100644 > --- a/hw/xen_backend.c > +++ b/hw/xen_backend.c > @@ -59,7 +59,7 @@ int xenstore_write_str(const char *base, const char *node, const char *val) > > snprintf(abspath, sizeof(abspath), "%s/%s", base, node); > if (!xs_write(xenstore, 0, abspath, val, strlen(val))) > - return -1; > + return -1; > I know it's a bit of a pain, but we should add {}s here if we're going to do a change like this. That way we're just breaking git blame once. The lack of {}s is also more visually offensive. Regards, Anthony Liguori > return 0; > } > > @@ -95,7 +95,7 @@ int xenstore_read_int(const char *base, const char *node, int *ival) > > val = xenstore_read_str(base, node); > if (val&& 1 == sscanf(val, "%d", ival)) > - rc = 0; > + rc = 0; > qemu_free(val); > return rc; > } > @@ -134,16 +134,16 @@ int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival) > > const char *xenbus_strstate(enum xenbus_state state) > { > - static const char *const name[] = { > - [ XenbusStateUnknown ] = "Unknown", > - [ XenbusStateInitialising ] = "Initialising", > - [ XenbusStateInitWait ] = "InitWait", > - [ XenbusStateInitialised ] = "Initialised", > - [ XenbusStateConnected ] = "Connected", > - [ XenbusStateClosing ] = "Closing", > - [ XenbusStateClosed ] = "Closed", > - }; > - return (state< ARRAY_SIZE(name)) ? name[state] : "INVALID"; > + static const char *const name[] = { > + [ XenbusStateUnknown ] = "Unknown", > + [ XenbusStateInitialising ] = "Initialising", > + [ XenbusStateInitWait ] = "InitWait", > + [ XenbusStateInitialised ] = "Initialised", > + [ XenbusStateConnected ] = "Connected", > + [ XenbusStateClosing ] = "Closing", > + [ XenbusStateClosed ] = "Closed", > + }; > + return (state< ARRAY_SIZE(name)) ? name[state] : "INVALID"; > } > > int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state) > @@ -152,9 +152,9 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state) > > rc = xenstore_write_be_int(xendev, "state", state); > if (rc< 0) > - return rc; > + return rc; > xen_be_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; > return 0; > } > @@ -166,13 +166,13 @@ 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) > - continue; > - if (xendev->dev != dev) > - continue; > - if (strcmp(xendev->type, type) != 0) > - continue; > - return xendev; > + if (xendev->dom != dom) > + continue; > + if (xendev->dev != dev) > + continue; > + if (strcmp(xendev->type, type) != 0) > + continue; > + return xendev; > } > return NULL; > } > @@ -188,7 +188,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, > > xendev = xen_be_find_xendev(type, dom, dev); > if (xendev) > - return xendev; > + return xendev; > > /* init new xendev */ > xendev = qemu_mallocz(ops->size); > @@ -199,9 +199,9 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, > > dom0 = xs_get_domain_path(xenstore, 0); > snprintf(xendev->be, sizeof(xendev->be), "%s/backend/%s/%d/%d", > - dom0, xendev->type, xendev->dom, xendev->dev); > + dom0, xendev->type, xendev->dom, xendev->dev); > snprintf(xendev->name, sizeof(xendev->name), "%s-%d", > - xendev->type, xendev->dev); > + xendev->type, xendev->dev); > free(dom0); > > xendev->debug = debug; > @@ -209,28 +209,28 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, > > xendev->evtchndev = xc_evtchn_open(); > if (xendev->evtchndev< 0) { > - xen_be_printf(NULL, 0, "can't open evtchn device\n"); > - qemu_free(xendev); > - return NULL; > + xen_be_printf(NULL, 0, "can't open evtchn device\n"); > + qemu_free(xendev); > + return NULL; > } > fcntl(xc_evtchn_fd(xendev->evtchndev), F_SETFD, FD_CLOEXEC); > > if (ops->flags& DEVOPS_FLAG_NEED_GNTDEV) { > - xendev->gnttabdev = xc_gnttab_open(); > - if (xendev->gnttabdev< 0) { > - xen_be_printf(NULL, 0, "can't open gnttab device\n"); > - xc_evtchn_close(xendev->evtchndev); > - qemu_free(xendev); > - return NULL; > - } > + xendev->gnttabdev = xc_gnttab_open(); > + if (xendev->gnttabdev< 0) { > + xen_be_printf(NULL, 0, "can't open gnttab device\n"); > + xc_evtchn_close(xendev->evtchndev); > + qemu_free(xendev); > + return NULL; > + } > } else { > - xendev->gnttabdev = -1; > + xendev->gnttabdev = -1; > } > > QTAILQ_INSERT_TAIL(&xendevs, xendev, next); > > if (xendev->ops->alloc) > - xendev->ops->alloc(xendev); > + xendev->ops->alloc(xendev); > > return xendev; > } > @@ -251,28 +251,28 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev) > xendev = xnext; > xnext = xendev->next.tqe_next; > > - if (xendev->dom != dom) > - continue; > - if (xendev->dev != dev&& dev != -1) > - continue; > + if (xendev->dom != dom) > + continue; > + if (xendev->dev != dev&& dev != -1) > + continue; > > - if (xendev->ops->free) > - xendev->ops->free(xendev); > + if (xendev->ops->free) > + xendev->ops->free(xendev); > > - if (xendev->fe) { > - char token[XEN_BUFSIZE]; > - snprintf(token, sizeof(token), "fe:%p", xendev); > - xs_unwatch(xenstore, xendev->fe, token); > - qemu_free(xendev->fe); > - } > + if (xendev->fe) { > + char token[XEN_BUFSIZE]; > + snprintf(token, sizeof(token), "fe:%p", xendev); > + xs_unwatch(xenstore, xendev->fe, token); > + qemu_free(xendev->fe); > + } > > - if (xendev->evtchndev>= 0) > - xc_evtchn_close(xendev->evtchndev); > - if (xendev->gnttabdev>= 0) > - xc_gnttab_close(xendev->gnttabdev); > + if (xendev->evtchndev>= 0) > + xc_evtchn_close(xendev->evtchndev); > + if (xendev->gnttabdev>= 0) > + xc_gnttab_close(xendev->gnttabdev); > > - QTAILQ_REMOVE(&xendevs, xendev, next); > - qemu_free(xendev); > + QTAILQ_REMOVE(&xendevs, xendev, next); > + qemu_free(xendev); > } > return NULL; > } > @@ -285,14 +285,14 @@ 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) > - xendev->online = 0; > + 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) > - xendev->ops->backend_changed(xendev, node); > + xen_be_printf(xendev, 2, "backend update: %s\n", node); > + if (xendev->ops->backend_changed) > + xendev->ops->backend_changed(xendev, node); > } > } > > @@ -301,25 +301,25 @@ 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) > - fe_state = XenbusStateUnknown; > - 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 (xenstore_read_fe_int(xendev, "state",&fe_state) == -1) > + fe_state = XenbusStateUnknown; > + 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) > - xen_be_printf(xendev, 1, "frontend protocol: %s\n", xendev->protocol); > + qemu_free(xendev->protocol); > + xendev->protocol = xenstore_read_fe_str(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) > - xendev->ops->frontend_changed(xendev, node); > + xen_be_printf(xendev, 2, "frontend update: %s\n", node); > + if (xendev->ops->frontend_changed) > + xendev->ops->frontend_changed(xendev, node); > } > } > > @@ -340,28 +340,28 @@ static int xen_be_try_setup(struct XenDevice *xendev) > int be_state; > > if (xenstore_read_be_int(xendev, "state",&be_state) == -1) { > - xen_be_printf(xendev, 0, "reading backend state failed\n"); > - return -1; > + xen_be_printf(xendev, 0, "reading backend state failed\n"); > + return -1; > } > > if (be_state != XenbusStateInitialising) { > - xen_be_printf(xendev, 0, "initial backend state is wrong (%s)\n", > - xenbus_strstate(be_state)); > - return -1; > + xen_be_printf(xendev, 0, "initial backend state is wrong (%s)\n", > + xenbus_strstate(be_state)); > + return -1; > } > > xendev->fe = xenstore_read_be_str(xendev, "frontend"); > if (xendev->fe == NULL) { > - xen_be_printf(xendev, 0, "reading frontend path failed\n"); > - return -1; > + xen_be_printf(xendev, 0, "reading frontend path failed\n"); > + return -1; > } > > /* setup frontend watch */ > snprintf(token, sizeof(token), "fe:%p", xendev); > if (!xs_watch(xenstore, xendev->fe, token)) { > - xen_be_printf(xendev, 0, "watching frontend path (%s) failed\n", > - xendev->fe); > - return -1; > + xen_be_printf(xendev, 0, "watching frontend path (%s) failed\n", > + xendev->fe); > + return -1; > } > xen_be_set_state(xendev, XenbusStateInitialising); > > @@ -383,15 +383,15 @@ static int xen_be_try_init(struct XenDevice *xendev) > int rc = 0; > > if (!xendev->online) { > - xen_be_printf(xendev, 1, "not online\n"); > - return -1; > + xen_be_printf(xendev, 1, "not online\n"); > + return -1; > } > > if (xendev->ops->init) > - rc = xendev->ops->init(xendev); > + rc = xendev->ops->init(xendev); > if (rc != 0) { > - xen_be_printf(xendev, 1, "init() failed\n"); > - return rc; > + xen_be_printf(xendev, 1, "init() failed\n"); > + return rc; > } > > xenstore_write_be_str(xendev, "hotplug-status", "connected"); > @@ -411,20 +411,20 @@ static int xen_be_try_connect(struct XenDevice *xendev) > int rc = 0; > > if (xendev->fe_state != XenbusStateInitialised&& > - xendev->fe_state != XenbusStateConnected) { > - if (xendev->ops->flags& DEVOPS_FLAG_IGNORE_STATE) { > - xen_be_printf(xendev, 2, "frontend not ready, ignoring\n"); > - } else { > - xen_be_printf(xendev, 2, "frontend not ready (yet)\n"); > - return -1; > - } > + xendev->fe_state != XenbusStateConnected) { > + if (xendev->ops->flags& DEVOPS_FLAG_IGNORE_STATE) { > + xen_be_printf(xendev, 2, "frontend not ready, ignoring\n"); > + } else { > + xen_be_printf(xendev, 2, "frontend not ready (yet)\n"); > + return -1; > + } > } > > if (xendev->ops->connect) > - rc = xendev->ops->connect(xendev); > + rc = xendev->ops->connect(xendev); > if (rc != 0) { > - xen_be_printf(xendev, 0, "connect() failed\n"); > - return rc; > + xen_be_printf(xendev, 0, "connect() failed\n"); > + return rc; > } > > xen_be_set_state(xendev, XenbusStateConnected); > @@ -441,7 +441,7 @@ 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); > + xendev->ops->disconnect(xendev); > if (xendev->be_state != state) > xen_be_set_state(xendev, state); > } > @@ -468,31 +468,31 @@ void xen_be_check_state(struct XenDevice *xendev) > > /* frontend may request shutdown from almost anywhere */ > if (xendev->fe_state == XenbusStateClosing || > - xendev->fe_state == XenbusStateClosed) { > - xen_be_disconnect(xendev, xendev->fe_state); > - return; > + xendev->fe_state == XenbusStateClosed) { > + xen_be_disconnect(xendev, xendev->fe_state); > + return; > } > > /* check for possible backend state transitions */ > for (;;) { > - switch (xendev->be_state) { > - case XenbusStateUnknown: > - rc = xen_be_try_setup(xendev); > - break; > - case XenbusStateInitialising: > - rc = xen_be_try_init(xendev); > - break; > - case XenbusStateInitWait: > - rc = xen_be_try_connect(xendev); > - break; > + switch (xendev->be_state) { > + case XenbusStateUnknown: > + rc = xen_be_try_setup(xendev); > + break; > + case XenbusStateInitialising: > + rc = xen_be_try_init(xendev); > + break; > + case XenbusStateInitWait: > + rc = xen_be_try_connect(xendev); > + break; > case XenbusStateClosed: > rc = xen_be_try_reset(xendev); > break; > - default: > - rc = -1; > - } > - if (rc != 0) > - break; > + default: > + rc = -1; > + } > + if (rc != 0) > + break; > } > } > > @@ -511,26 +511,26 @@ static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops) > snprintf(path, sizeof(path), "%s/backend/%s/%d", dom0, type, dom); > free(dom0); > if (!xs_watch(xenstore, path, token)) { > - xen_be_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", path); > - return -1; > + xen_be_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", path); > + return -1; > } > > /* look for backends */ > dev = xs_directory(xenstore, 0, path,&cdev); > if (!dev) > - return 0; > + return 0; > for (j = 0; j< cdev; j++) { > - xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops); > - if (xendev == NULL) > - continue; > - xen_be_check_state(xendev); > + xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops); > + if (xendev == NULL) > + continue; > + xen_be_check_state(xendev); > } > free(dev); > return 0; > } > > static void xenstore_update_be(char *watch, char *type, int dom, > - struct XenDevOps *ops) > + struct XenDevOps *ops) > { > struct XenDevice *xendev; > char path[XEN_BUFSIZE], *dom0; > @@ -540,24 +540,24 @@ static void xenstore_update_be(char *watch, char *type, int dom, > len = snprintf(path, sizeof(path), "%s/backend/%s/%d", dom0, type, dom); > free(dom0); > if (strncmp(path, watch, len) != 0) > - return; > + return; > if (sscanf(watch+len, "/%u/%255s",&dev, path) != 2) { > - strcpy(path, ""); > - if (sscanf(watch+len, "/%u",&dev) != 1) > - dev = -1; > + strcpy(path, ""); > + if (sscanf(watch+len, "/%u",&dev) != 1) > + dev = -1; > } > if (dev == -1) > - return; > + return; > > if (0) { > - /* FIXME: detect devices being deleted from xenstore ... */ > - xen_be_del_xendev(dom, dev); > + /* FIXME: detect devices being deleted from xenstore ... */ > + xen_be_del_xendev(dom, dev); > } > > xendev = xen_be_get_xendev(type, dom, dev, ops); > if (xendev != NULL) { > - xen_be_backend_changed(xendev, path); > - xen_be_check_state(xendev); > + xen_be_backend_changed(xendev, path); > + xen_be_check_state(xendev); > } > } > > @@ -568,9 +568,9 @@ static void xenstore_update_fe(char *watch, struct XenDevice *xendev) > > len = strlen(xendev->fe); > if (strncmp(xendev->fe, watch, len) != 0) > - return; > + return; > if (watch[len] != '/') > - return; > + return; > node = watch + len + 1; > > xen_be_frontend_changed(xendev, node); > @@ -585,13 +585,13 @@ static void xenstore_update(void *unused) > > vec = xs_read_watch(xenstore,&count); > if (vec == NULL) > - goto cleanup; > + goto cleanup; > > if (sscanf(vec[XS_WATCH_TOKEN], "be:%" PRIxPTR ":%d:%" PRIxPTR, > &type,&dom,&ops) == 3) > - xenstore_update_be(vec[XS_WATCH_PATH], (void*)type, dom, (void*)ops); > + xenstore_update_be(vec[XS_WATCH_PATH], (void*)type, dom, (void*)ops); > if (sscanf(vec[XS_WATCH_TOKEN], "fe:%" PRIxPTR,&ptr) == 1) > - xenstore_update_fe(vec[XS_WATCH_PATH], (void*)ptr); > + xenstore_update_fe(vec[XS_WATCH_PATH], (void*)ptr); > > cleanup: > free(vec); > @@ -604,14 +604,14 @@ static void xen_be_evtchn_event(void *opaque) > > port = xc_evtchn_pending(xendev->evtchndev); > if (port != xendev->local_port) { > - xen_be_printf(xendev, 0, "xc_evtchn_pending returned %d (expected %d)\n", > - port, xendev->local_port); > - return; > + xen_be_printf(xendev, 0, "xc_evtchn_pending returned %d (expected %d)\n", > + port, xendev->local_port); > + return; > } > xc_evtchn_unmask(xendev->evtchndev, port); > > if (xendev->ops->event) > - xendev->ops->event(xendev); > + xendev->ops->event(xendev); > } > > /* -------------------------------------------------------------------- */ > @@ -620,17 +620,17 @@ int xen_be_init(void) > { > xenstore = xs_daemon_open(); > if (!xenstore) { > - xen_be_printf(NULL, 0, "can't connect to xenstored\n"); > - return -1; > + xen_be_printf(NULL, 0, "can't connect to xenstored\n"); > + return -1; > } > > if (qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL)< 0) > - goto err; > + goto err; > > xen_xc = xc_interface_open(); > if (xen_xc == -1) { > - xen_be_printf(NULL, 0, "can't open xen interface\n"); > - goto err; > + xen_be_printf(NULL, 0, "can't open xen interface\n"); > + goto err; > } > return 0; > > @@ -650,23 +650,23 @@ int xen_be_register(const char *type, struct XenDevOps *ops) > int xen_be_bind_evtchn(struct XenDevice *xendev) > { > if (xendev->local_port != -1) > - return 0; > + return 0; > xendev->local_port = xc_evtchn_bind_interdomain > - (xendev->evtchndev, xendev->dom, xendev->remote_port); > + (xendev->evtchndev, xendev->dom, xendev->remote_port); > if (xendev->local_port == -1) { > - xen_be_printf(xendev, 0, "xc_evtchn_bind_interdomain failed\n"); > - return -1; > + xen_be_printf(xendev, 0, "xc_evtchn_bind_interdomain failed\n"); > + return -1; > } > xen_be_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port); > qemu_set_fd_handler(xc_evtchn_fd(xendev->evtchndev), > - xen_be_evtchn_event, NULL, xendev); > + xen_be_evtchn_event, NULL, xendev); > return 0; > } > > void xen_be_unbind_evtchn(struct XenDevice *xendev) > { > if (xendev->local_port == -1) > - return; > + 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); > diff --git a/hw/xen_disk.c b/hw/xen_disk.c > index ed9e5eb..7f6aaca 100644 > --- a/hw/xen_disk.c > +++ b/hw/xen_disk.c > @@ -120,17 +120,17 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev) > struct ioreq *ioreq = NULL; > > if (QLIST_EMPTY(&blkdev->freelist)) { > - if (blkdev->requests_total>= max_requests) > - goto out; > - /* allocate new struct */ > - ioreq = qemu_mallocz(sizeof(*ioreq)); > - ioreq->blkdev = blkdev; > - blkdev->requests_total++; > + if (blkdev->requests_total>= max_requests) > + goto out; > + /* allocate new struct */ > + ioreq = qemu_mallocz(sizeof(*ioreq)); > + ioreq->blkdev = blkdev; > + blkdev->requests_total++; > qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST); > } else { > - /* get one from freelist */ > - ioreq = QLIST_FIRST(&blkdev->freelist); > - QLIST_REMOVE(ioreq, list); > + /* get one from freelist */ > + ioreq = QLIST_FIRST(&blkdev->freelist); > + QLIST_REMOVE(ioreq, list); > qemu_iovec_reset(&ioreq->v); > } > QLIST_INSERT_HEAD(&blkdev->inflight, ioreq, list); > @@ -173,30 +173,30 @@ static int ioreq_parse(struct ioreq *ioreq) > int i; > > xen_be_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); > + "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); > switch (ioreq->req.operation) { > case BLKIF_OP_READ: > - ioreq->prot = PROT_WRITE; /* to memory */ > - break; > + ioreq->prot = PROT_WRITE; /* to memory */ > + break; > case BLKIF_OP_WRITE_BARRIER: > if (!ioreq->req.nr_segments) { > ioreq->presync = 1; > return 0; > } > - if (!syncwrite) > - ioreq->presync = ioreq->postsync = 1; > - /* fall through */ > + if (!syncwrite) > + ioreq->presync = ioreq->postsync = 1; > + /* fall through */ > case BLKIF_OP_WRITE: > - ioreq->prot = PROT_READ; /* from memory */ > - if (syncwrite) > - ioreq->postsync = 1; > - break; > + ioreq->prot = PROT_READ; /* from memory */ > + if (syncwrite) > + ioreq->postsync = 1; > + break; > default: > - xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n", > - ioreq->req.operation); > - goto err; > + xen_be_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') { > @@ -206,29 +206,29 @@ static int ioreq_parse(struct ioreq *ioreq) > > 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"); > - 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"); > - goto err; > - } > - if (ioreq->req.seg[i].last_sect * BLOCK_SIZE>= XC_PAGE_SIZE) { > - xen_be_printf(&blkdev->xendev, 0, "error: page crossing\n"); > - goto err; > - } > - > - ioreq->domids[i] = blkdev->xendev.dom; > - ioreq->refs[i] = ioreq->req.seg[i].gref; > - > - mem = ioreq->req.seg[i].first_sect * blkdev->file_blk; > - len = (ioreq->req.seg[i].last_sect - ioreq->req.seg[i].first_sect + 1) * blkdev->file_blk; > + if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) { > + xen_be_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"); > + goto err; > + } > + if (ioreq->req.seg[i].last_sect * BLOCK_SIZE>= XC_PAGE_SIZE) { > + xen_be_printf(&blkdev->xendev, 0, "error: page crossing\n"); > + goto err; > + } > + > + ioreq->domids[i] = blkdev->xendev.dom; > + ioreq->refs[i] = ioreq->req.seg[i].gref; > + > + mem = ioreq->req.seg[i].first_sect * blkdev->file_blk; > + len = (ioreq->req.seg[i].last_sect - ioreq->req.seg[i].first_sect + 1) * blkdev->file_blk; > 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"); > - goto err; > + xen_be_printf(&blkdev->xendev, 0, "error: access beyond end of file\n"); > + goto err; > } > return 0; > > @@ -245,23 +245,23 @@ static void ioreq_unmap(struct ioreq *ioreq) > if (ioreq->v.niov == 0) > return; > if (batch_maps) { > - if (!ioreq->pages) > - return; > - 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; > + if (!ioreq->pages) > + return; > + 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]) > - continue; > - 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; > - } > + for (i = 0; i< ioreq->v.niov; i++) { > + if (!ioreq->page[i]) > + continue; > + 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; > + } > } > } > > @@ -273,32 +273,32 @@ static int ioreq_map(struct ioreq *ioreq) > 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); > - if (ioreq->pages == NULL) { > - xen_be_printf(&ioreq->blkdev->xendev, 0, > - "can't map %d grant refs (%s, %d maps)\n", > - ioreq->v.niov, strerror(errno), ioreq->blkdev->cnt_map); > - return -1; > - } > - 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; > + ioreq->pages = xc_gnttab_map_grant_refs > + (gnt, ioreq->v.niov, ioreq->domids, ioreq->refs, ioreq->prot); > + if (ioreq->pages == NULL) { > + xen_be_printf(&ioreq->blkdev->xendev, 0, > + "can't map %d grant refs (%s, %d maps)\n", > + ioreq->v.niov, strerror(errno), ioreq->blkdev->cnt_map); > + return -1; > + } > + 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++) { > - ioreq->page[i] = xc_gnttab_map_grant_ref > - (gnt, ioreq->domids[i], ioreq->refs[i], ioreq->prot); > - if (ioreq->page[i] == NULL) { > - xen_be_printf(&ioreq->blkdev->xendev, 0, > - "can't map grant ref %d (%s, %d maps)\n", > - ioreq->refs[i], strerror(errno), ioreq->blkdev->cnt_map); > - ioreq_unmap(ioreq); > - return -1; > - } > - ioreq->v.iov[i].iov_base = ioreq->page[i] + (uintptr_t)ioreq->v.iov[i].iov_base; > - ioreq->blkdev->cnt_map++; > - } > + for (i = 0; i< ioreq->v.niov; i++) { > + ioreq->page[i] = xc_gnttab_map_grant_ref > + (gnt, ioreq->domids[i], ioreq->refs[i], ioreq->prot); > + if (ioreq->page[i] == NULL) { > + xen_be_printf(&ioreq->blkdev->xendev, 0, > + "can't map grant ref %d (%s, %d maps)\n", > + ioreq->refs[i], strerror(errno), ioreq->blkdev->cnt_map); > + ioreq_unmap(ioreq); > + return -1; > + } > + ioreq->v.iov[i].iov_base = ioreq->page[i] + (uintptr_t)ioreq->v.iov[i].iov_base; > + ioreq->blkdev->cnt_map++; > + } > } > return 0; > } > @@ -310,53 +310,53 @@ static int ioreq_runio_qemu_sync(struct ioreq *ioreq) > off_t pos; > > if (ioreq->req.nr_segments&& ioreq_map(ioreq) == -1) > - goto err; > + goto err; > if (ioreq->presync) > - bdrv_flush(blkdev->bs); > + bdrv_flush(blkdev->bs); > > switch (ioreq->req.operation) { > case BLKIF_OP_READ: > - pos = ioreq->start; > - for (i = 0; i< ioreq->v.niov; i++) { > - rc = bdrv_read(blkdev->bs, pos / BLOCK_SIZE, > - ioreq->v.iov[i].iov_base, > - ioreq->v.iov[i].iov_len / BLOCK_SIZE); > - if (rc != 0) { > - xen_be_printf(&blkdev->xendev, 0, "rd I/O error (%p, len %zd)\n", > - ioreq->v.iov[i].iov_base, > - ioreq->v.iov[i].iov_len); > - goto err; > - } > - len += ioreq->v.iov[i].iov_len; > - pos += ioreq->v.iov[i].iov_len; > - } > - break; > + pos = ioreq->start; > + for (i = 0; i< ioreq->v.niov; i++) { > + rc = bdrv_read(blkdev->bs, pos / BLOCK_SIZE, > + ioreq->v.iov[i].iov_base, > + ioreq->v.iov[i].iov_len / BLOCK_SIZE); > + if (rc != 0) { > + xen_be_printf(&blkdev->xendev, 0, "rd I/O error (%p, len %zd)\n", > + ioreq->v.iov[i].iov_base, > + ioreq->v.iov[i].iov_len); > + goto err; > + } > + len += ioreq->v.iov[i].iov_len; > + pos += ioreq->v.iov[i].iov_len; > + } > + break; > case BLKIF_OP_WRITE: > case BLKIF_OP_WRITE_BARRIER: > 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, > - ioreq->v.iov[i].iov_base, > - ioreq->v.iov[i].iov_len / BLOCK_SIZE); > - if (rc != 0) { > - xen_be_printf(&blkdev->xendev, 0, "wr I/O error (%p, len %zd)\n", > - ioreq->v.iov[i].iov_base, > - ioreq->v.iov[i].iov_len); > - goto err; > - } > - len += ioreq->v.iov[i].iov_len; > - pos += ioreq->v.iov[i].iov_len; > - } > - break; > + pos = ioreq->start; > + for (i = 0; i< ioreq->v.niov; i++) { > + rc = bdrv_write(blkdev->bs, pos / BLOCK_SIZE, > + ioreq->v.iov[i].iov_base, > + ioreq->v.iov[i].iov_len / BLOCK_SIZE); > + if (rc != 0) { > + xen_be_printf(&blkdev->xendev, 0, "wr I/O error (%p, len %zd)\n", > + ioreq->v.iov[i].iov_base, > + ioreq->v.iov[i].iov_len); > + goto err; > + } > + len += ioreq->v.iov[i].iov_len; > + pos += ioreq->v.iov[i].iov_len; > + } > + break; > default: > - /* unknown operation (shouldn't happen -- parse catches this) */ > - goto err; > + /* unknown operation (shouldn't happen -- parse catches this) */ > + goto err; > } > > if (ioreq->postsync) > - bdrv_flush(blkdev->bs); > + bdrv_flush(blkdev->bs); > ioreq->status = BLKIF_RSP_OKAY; > > ioreq_unmap(ioreq); > @@ -393,11 +393,11 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) > struct XenBlkDev *blkdev = ioreq->blkdev; > > if (ioreq->req.nr_segments&& ioreq_map(ioreq) == -1) > - goto err; > + goto err; > > ioreq->aio_inflight++; > if (ioreq->presync) > - bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */ > + bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */ > > switch (ioreq->req.operation) { > case BLKIF_OP_READ: > @@ -405,7 +405,7 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) > bdrv_aio_readv(blkdev->bs, ioreq->start / BLOCK_SIZE, > &ioreq->v, ioreq->v.size / BLOCK_SIZE, > qemu_aio_complete, ioreq); > - break; > + break; > case BLKIF_OP_WRITE: > case BLKIF_OP_WRITE_BARRIER: > ioreq->aio_inflight++; > @@ -414,14 +414,14 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) > bdrv_aio_writev(blkdev->bs, ioreq->start / BLOCK_SIZE, > &ioreq->v, ioreq->v.size / BLOCK_SIZE, > qemu_aio_complete, ioreq); > - break; > + break; > default: > - /* unknown operation (shouldn't happen -- parse catches this) */ > - goto err; > + /* unknown operation (shouldn't happen -- parse catches this) */ > + goto err; > } > > if (ioreq->postsync) > - bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */ > + bdrv_flush(blkdev->bs); /* FIXME: aio_flush() ??? */ > qemu_aio_complete(ioreq, 0); > > return 0; > @@ -446,36 +446,36 @@ static int blk_send_response_one(struct ioreq *ioreq) > /* Place on the response ring for the relevant domain. */ > switch (blkdev->protocol) { > case BLKIF_PROTOCOL_NATIVE: > - dst = RING_GET_RESPONSE(&blkdev->rings.native, blkdev->rings.native.rsp_prod_pvt); > - break; > + dst = RING_GET_RESPONSE(&blkdev->rings.native, blkdev->rings.native.rsp_prod_pvt); > + break; > case BLKIF_PROTOCOL_X86_32: > dst = RING_GET_RESPONSE(&blkdev->rings.x86_32_part, > blkdev->rings.x86_32_part.rsp_prod_pvt); > - break; > + break; > case BLKIF_PROTOCOL_X86_64: > dst = RING_GET_RESPONSE(&blkdev->rings.x86_64_part, > blkdev->rings.x86_64_part.rsp_prod_pvt); > - break; > + break; > default: > - dst = NULL; > + dst = NULL; > } > memcpy(dst,&resp, sizeof(resp)); > blkdev->rings.common.rsp_prod_pvt++; > > RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blkdev->rings.common, send_notify); > if (blkdev->rings.common.rsp_prod_pvt == blkdev->rings.common.req_cons) { > - /* > - * Tail check for pending requests. Allows frontend to avoid > - * notifications if requests are already in flight (lower > - * overheads and promotes batching). > - */ > - RING_FINAL_CHECK_FOR_REQUESTS(&blkdev->rings.common, have_requests); > + /* > + * Tail check for pending requests. Allows frontend to avoid > + * notifications if requests are already in flight (lower > + * overheads and promotes batching). > + */ > + RING_FINAL_CHECK_FOR_REQUESTS(&blkdev->rings.common, have_requests); > } else if (RING_HAS_UNCONSUMED_REQUESTS(&blkdev->rings.common)) { > - have_requests = 1; > + have_requests = 1; > } > > if (have_requests) > - blkdev->more_work++; > + blkdev->more_work++; > return send_notify; > } > > @@ -487,28 +487,28 @@ static void blk_send_response_all(struct XenBlkDev *blkdev) > > while (!QLIST_EMPTY(&blkdev->finished)) { > ioreq = QLIST_FIRST(&blkdev->finished); > - send_notify += blk_send_response_one(ioreq); > - ioreq_release(ioreq); > + send_notify += blk_send_response_one(ioreq); > + ioreq_release(ioreq); > } > if (send_notify) > - xen_be_send_notify(&blkdev->xendev); > + xen_be_send_notify(&blkdev->xendev); > } > > static int blk_get_request(struct XenBlkDev *blkdev, struct ioreq *ioreq, RING_IDX rc) > { > switch (blkdev->protocol) { > case BLKIF_PROTOCOL_NATIVE: > - memcpy(&ioreq->req, RING_GET_REQUEST(&blkdev->rings.native, rc), > - sizeof(ioreq->req)); > - break; > + memcpy(&ioreq->req, RING_GET_REQUEST(&blkdev->rings.native, rc), > + sizeof(ioreq->req)); > + break; > case BLKIF_PROTOCOL_X86_32: > blkif_get_x86_32_req(&ioreq->req, > RING_GET_REQUEST(&blkdev->rings.x86_32_part, rc)); > - break; > + break; > case BLKIF_PROTOCOL_X86_64: > blkif_get_x86_64_req(&ioreq->req, > RING_GET_REQUEST(&blkdev->rings.x86_64_part, rc)); > - break; > + break; > } > return 0; > } > @@ -589,44 +589,44 @@ static int blk_init(struct XenDevice *xendev) > > /* read xenstore entries */ > if (blkdev->params == NULL) { > - blkdev->params = xenstore_read_be_str(&blkdev->xendev, "params"); > + blkdev->params = xenstore_read_be_str(&blkdev->xendev, "params"); > h = strchr(blkdev->params, ':'); > - if (h != NULL) { > - blkdev->fileproto = blkdev->params; > - blkdev->filename = h+1; > - *h = 0; > - } else { > - blkdev->fileproto = ""; > - blkdev->filename = blkdev->params; > - } > + if (h != NULL) { > + blkdev->fileproto = blkdev->params; > + blkdev->filename = h+1; > + *h = 0; > + } else { > + blkdev->fileproto = ""; > + blkdev->filename = blkdev->params; > + } > } > if (blkdev->mode == NULL) > - blkdev->mode = xenstore_read_be_str(&blkdev->xendev, "mode"); > + blkdev->mode = xenstore_read_be_str(&blkdev->xendev, "mode"); > if (blkdev->type == NULL) > - blkdev->type = xenstore_read_be_str(&blkdev->xendev, "type"); > + blkdev->type = xenstore_read_be_str(&blkdev->xendev, "type"); > if (blkdev->dev == NULL) > - blkdev->dev = xenstore_read_be_str(&blkdev->xendev, "dev"); > + blkdev->dev = xenstore_read_be_str(&blkdev->xendev, "dev"); > if (blkdev->devtype == NULL) > - blkdev->devtype = xenstore_read_be_str(&blkdev->xendev, "device-type"); > + 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) > - return -1; > + blkdev->mode == NULL || > + blkdev->type == NULL || > + blkdev->dev == NULL) > + return -1; > > /* read-only ? */ > if (strcmp(blkdev->mode, "w") == 0) { > - qflags = BDRV_O_RDWR; > + qflags = BDRV_O_RDWR; > } else { > - qflags = 0; > - info |= VDISK_READONLY; > + qflags = 0; > + info |= VDISK_READONLY; > } > > /* cdrom ? */ > if (blkdev->devtype&& !strcmp(blkdev->devtype, "cdrom")) > - info |= VDISK_CDROM; > + info |= VDISK_CDROM; > > /* init qemu block driver */ > index = (blkdev->xendev.dev - 202 * 256) / 16; > @@ -643,7 +643,7 @@ static int blk_init(struct XenDevice *xendev) > } else { > /* setup via qemu cmdline -> already setup for us */ > xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n"); > - blkdev->bs = blkdev->dinfo->bdrv; > + blkdev->bs = blkdev->dinfo->bdrv; > } > blkdev->file_blk = BLOCK_SIZE; > blkdev->file_size = bdrv_getlength(blkdev->bs); > @@ -651,21 +651,21 @@ static int blk_init(struct XenDevice *xendev) > xen_be_printf(&blkdev->xendev, 1, "bdrv_getlength: %d (%s) | drv %s\n", > (int)blkdev->file_size, strerror(-blkdev->file_size), > blkdev->bs->drv ? blkdev->bs->drv->format_name : "-"); > - blkdev->file_size = 0; > + blkdev->file_size = 0; > } > have_barriers = blkdev->bs->drv&& blkdev->bs->drv->bdrv_flush ? 1 : 0; > > xen_be_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); > + " size %" PRId64 " (%" PRId64 " MB)\n", > + blkdev->type, blkdev->fileproto, blkdev->filename, > + blkdev->file_size, blkdev->file_size>> 20); > > /* fill info */ > xenstore_write_be_int(&blkdev->xendev, "feature-barrier", have_barriers); > xenstore_write_be_int(&blkdev->xendev, "info", info); > xenstore_write_be_int(&blkdev->xendev, "sector-size", blkdev->file_blk); > xenstore_write_be_int(&blkdev->xendev, "sectors", > - blkdev->file_size / blkdev->file_blk); > + blkdev->file_size / blkdev->file_blk); > return 0; > } > > @@ -674,10 +674,10 @@ 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) > - return -1; > + return -1; > if (xenstore_read_fe_int(&blkdev->xendev, "event-channel", > &blkdev->xendev.remote_port) == -1) > - return -1; > + return -1; > > blkdev->protocol = BLKIF_PROTOCOL_NATIVE; > if (blkdev->xendev.protocol) { > @@ -688,42 +688,42 @@ static int blk_connect(struct XenDevice *xendev) > } > > blkdev->sring = xc_gnttab_map_grant_ref(blkdev->xendev.gnttabdev, > - blkdev->xendev.dom, > - blkdev->ring_ref, > - PROT_READ | PROT_WRITE); > + blkdev->xendev.dom, > + blkdev->ring_ref, > + PROT_READ | PROT_WRITE); > if (!blkdev->sring) > - return -1; > + return -1; > blkdev->cnt_map++; > > switch (blkdev->protocol) { > case BLKIF_PROTOCOL_NATIVE: > { > - blkif_sring_t *sring_native = blkdev->sring; > - BACK_RING_INIT(&blkdev->rings.native, sring_native, XC_PAGE_SIZE); > - break; > + blkif_sring_t *sring_native = blkdev->sring; > + BACK_RING_INIT(&blkdev->rings.native, sring_native, XC_PAGE_SIZE); > + break; > } > case BLKIF_PROTOCOL_X86_32: > { > - blkif_x86_32_sring_t *sring_x86_32 = blkdev->sring; > + blkif_x86_32_sring_t *sring_x86_32 = blkdev->sring; > > BACK_RING_INIT(&blkdev->rings.x86_32_part, sring_x86_32, XC_PAGE_SIZE); > - break; > + break; > } > case BLKIF_PROTOCOL_X86_64: > { > - blkif_x86_64_sring_t *sring_x86_64 = blkdev->sring; > + blkif_x86_64_sring_t *sring_x86_64 = blkdev->sring; > > BACK_RING_INIT(&blkdev->rings.x86_64_part, sring_x86_64, XC_PAGE_SIZE); > - break; > + break; > } > } > > xen_be_bind_evtchn(&blkdev->xendev); > > xen_be_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); > + "remote port %d, local port %d\n", > + blkdev->xendev.protocol, blkdev->ring_ref, > + blkdev->xendev.remote_port, blkdev->xendev.local_port); > return 0; > } > > @@ -737,14 +737,14 @@ static void blk_disconnect(struct XenDevice *xendev) > bdrv_close(blkdev->bs); > bdrv_delete(blkdev->bs); > } > - blkdev->bs = NULL; > + blkdev->bs = NULL; > } > xen_be_unbind_evtchn(&blkdev->xendev); > > if (blkdev->sring) { > - xc_gnttab_munmap(blkdev->xendev.gnttabdev, blkdev->sring, 1); > - blkdev->cnt_map--; > - blkdev->sring = NULL; > + xc_gnttab_munmap(blkdev->xendev.gnttabdev, blkdev->sring, 1); > + blkdev->cnt_map--; > + blkdev->sring = NULL; > } > } > > @@ -754,10 +754,10 @@ static int blk_free(struct XenDevice *xendev) > struct ioreq *ioreq; > > while (!QLIST_EMPTY(&blkdev->freelist)) { > - ioreq = QLIST_FIRST(&blkdev->freelist); > + ioreq = QLIST_FIRST(&blkdev->freelist); > QLIST_REMOVE(ioreq, list); > qemu_iovec_destroy(&ioreq->v); > - qemu_free(ioreq); > + qemu_free(ioreq); > } > > qemu_free(blkdev->params); > diff --git a/hw/xen_nic.c b/hw/xen_nic.c > index 08055b8..8fcf856 100644 > --- a/hw/xen_nic.c > +++ b/hw/xen_nic.c > @@ -75,19 +75,19 @@ static void net_tx_response(struct XenNetDev *netdev, netif_tx_request_t *txp, i > > #if 0 > if (txp->flags& NETTXF_extra_info) > - RING_GET_RESPONSE(&netdev->tx_ring, ++i)->status = NETIF_RSP_NULL; > + 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) > - xen_be_send_notify(&netdev->xendev); > + 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) > - netdev->tx_work++; > + int more_to_do; > + RING_FINAL_CHECK_FOR_REQUESTS(&netdev->tx_ring, more_to_do); > + if (more_to_do) > + netdev->tx_work++; > } > } > > @@ -101,10 +101,10 @@ static void net_tx_error(struct XenNetDev *netdev, netif_tx_request_t *txp, RING > RING_IDX cons = netdev->tx_ring.req_cons; > > do { > - make_tx_response(netif, txp, NETIF_RSP_ERROR); > - if (cons>= end) > - break; > - txp = RING_GET_REQUEST(&netdev->tx_ring, cons++); > + make_tx_response(netif, txp, NETIF_RSP_ERROR); > + if (cons>= end) > + break; > + txp = RING_GET_REQUEST(&netdev->tx_ring, cons++); > } while (1); > netdev->tx_ring.req_cons = cons; > netif_schedule_work(netif); > @@ -122,75 +122,75 @@ static void net_tx_packets(struct XenNetDev *netdev) > void *tmpbuf = NULL; > > for (;;) { > - rc = netdev->tx_ring.req_cons; > - rp = netdev->tx_ring.sring->req_prod; > - xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ > + rc = netdev->tx_ring.req_cons; > + rp = netdev->tx_ring.sring->req_prod; > + xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ > > - while ((rc != rp)) { > - 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; > + while ((rc != rp)) { > + 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; > > #if 1 > - /* 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"); > - net_tx_error(netdev,&txreq, rc); > - continue; > - } > - if (txreq.flags& NETTXF_more_data) { > - xen_be_printf(&netdev->xendev, 0, "FIXME: more data flag\n"); > - net_tx_error(netdev,&txreq, rc); > - continue; > - } > + /* 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"); > + net_tx_error(netdev,&txreq, rc); > + continue; > + } > + if (txreq.flags& NETTXF_more_data) { > + xen_be_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); > - 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"); > - 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", > - txreq.gref, txreq.offset, txreq.size, txreq.flags, > - (txreq.flags& NETTXF_csum_blank) ? " csum_blank" : "", > - (txreq.flags& NETTXF_data_validated) ? " data_validated" : "", > - (txreq.flags& NETTXF_more_data) ? " more_data" : "", > - (txreq.flags& NETTXF_extra_info) ? " extra_info" : ""); > - > - page = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev, > - netdev->xendev.dom, > - txreq.gref, PROT_READ); > - if (page == NULL) { > - xen_be_printf(&netdev->xendev, 0, "error: tx gref dereference failed (%d)\n", > + if (txreq.size< 14) { > + xen_be_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"); > + 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", > + txreq.gref, txreq.offset, txreq.size, txreq.flags, > + (txreq.flags& NETTXF_csum_blank) ? " csum_blank" : "", > + (txreq.flags& NETTXF_data_validated) ? " data_validated" : "", > + (txreq.flags& NETTXF_more_data) ? " more_data" : "", > + (txreq.flags& NETTXF_extra_info) ? " extra_info" : ""); > + > + page = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev, > + netdev->xendev.dom, > + txreq.gref, PROT_READ); > + if (page == NULL) { > + xen_be_printf(&netdev->xendev, 0, "error: tx gref dereference failed (%d)\n", > txreq.gref); > - net_tx_error(netdev,&txreq, rc); > - continue; > - } > - if (txreq.flags& NETTXF_csum_blank) { > + net_tx_error(netdev,&txreq, rc); > + continue; > + } > + if (txreq.flags& NETTXF_csum_blank) { > /* have read-only mapping -> can't fill checksum in-place */ > if (!tmpbuf) > tmpbuf = qemu_malloc(XC_PAGE_SIZE); > memcpy(tmpbuf, page + txreq.offset, txreq.size); > - net_checksum_calculate(tmpbuf, txreq.size); > + net_checksum_calculate(tmpbuf, txreq.size); > qemu_send_packet(&netdev->nic->nc, tmpbuf, txreq.size); > } else { > qemu_send_packet(&netdev->nic->nc, page + txreq.offset, txreq.size); > } > - xc_gnttab_munmap(netdev->xendev.gnttabdev, page, 1); > - net_tx_response(netdev,&txreq, NETIF_RSP_OKAY); > - } > - if (!netdev->tx_work) > - break; > - netdev->tx_work = 0; > + xc_gnttab_munmap(netdev->xendev.gnttabdev, page, 1); > + net_tx_response(netdev,&txreq, NETIF_RSP_OKAY); > + } > + if (!netdev->tx_work) > + break; > + netdev->tx_work = 0; > } > qemu_free(tmpbuf); > } > @@ -198,9 +198,9 @@ static void net_tx_packets(struct XenNetDev *netdev) > /* ------------------------------------------------------------- */ > > static void net_rx_response(struct XenNetDev *netdev, > - netif_rx_request_t *req, int8_t st, > - uint16_t offset, uint16_t size, > - uint16_t flags) > + netif_rx_request_t *req, int8_t st, > + uint16_t offset, uint16_t size, > + uint16_t flags) > { > RING_IDX i = netdev->rx_ring.rsp_prod_pvt; > netif_rx_response_t *resp; > @@ -212,15 +212,15 @@ static void net_rx_response(struct XenNetDev *netdev, > resp->id = req->id; > resp->status = (int16_t)size; > if (st< 0) > - resp->status = (int16_t)st; > + 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); > + 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_be_send_notify(&netdev->xendev); > } > > #define NET_IP_ALIGN 2 > @@ -231,16 +231,16 @@ static int net_rx_ok(VLANClientState *nc) > RING_IDX rc, rp; > > if (netdev->xendev.be_state != XenbusStateConnected) > - return 0; > + return 0; > > rc = netdev->rx_ring.req_cons; > rp = netdev->rx_ring.sring->req_prod; > xen_rmb(); > > if (rc == rp || RING_REQUEST_CONS_OVERFLOW(&netdev->rx_ring, rc)) { > - xen_be_printf(&netdev->xendev, 2, "%s: no rx buffers (%d/%d)\n", > - __FUNCTION__, rc, rp); > - return 0; > + xen_be_printf(&netdev->xendev, 2, "%s: no rx buffers (%d/%d)\n", > + __FUNCTION__, rc, rp); > + return 0; > } > return 1; > } > @@ -253,33 +253,33 @@ static ssize_t net_rx_packet(VLANClientState *nc, const uint8_t *buf, size_t siz > void *page; > > if (netdev->xendev.be_state != XenbusStateConnected) > - return -1; > + return -1; > > rc = netdev->rx_ring.req_cons; > rp = netdev->rx_ring.sring->req_prod; > xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ > > if (rc == rp || RING_REQUEST_CONS_OVERFLOW(&netdev->rx_ring, rc)) { > - xen_be_printf(&netdev->xendev, 2, "no buffer, drop packet\n"); > - return -1; > + xen_be_printf(&netdev->xendev, 2, "no buffer, drop packet\n"); > + return -1; > } > if (size> XC_PAGE_SIZE - NET_IP_ALIGN) { > - xen_be_printf(&netdev->xendev, 0, "packet too big (%lu> %ld)", > - (unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN); > - return -1; > + xen_be_printf(&netdev->xendev, 0, "packet too big (%lu> %ld)", > + (unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN); > + return -1; > } > > memcpy(&rxreq, RING_GET_REQUEST(&netdev->rx_ring, rc), sizeof(rxreq)); > netdev->rx_ring.req_cons = ++rc; > > page = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev, > - netdev->xendev.dom, > - rxreq.gref, PROT_WRITE); > + netdev->xendev.dom, > + rxreq.gref, PROT_WRITE); > if (page == NULL) { > - xen_be_printf(&netdev->xendev, 0, "error: rx gref dereference failed (%d)\n", > + xen_be_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; > + net_rx_response(netdev,&rxreq, NETIF_RSP_ERROR, 0, 0, 0); > + return -1; > } > memcpy(page + NET_IP_ALIGN, buf, size); > xc_gnttab_munmap(netdev->xendev.gnttabdev, page, 1); > @@ -303,11 +303,11 @@ static int net_init(struct XenDevice *xendev) > > /* read xenstore entries */ > if (netdev->mac == NULL) > - netdev->mac = xenstore_read_be_str(&netdev->xendev, "mac"); > + netdev->mac = xenstore_read_be_str(&netdev->xendev, "mac"); > > /* do we have all we need? */ > if (netdev->mac == NULL) > - return -1; > + return -1; > > if (net_parse_macaddr(netdev->conf.macaddr.a, netdev->mac)< 0) > return -1; > @@ -334,41 +334,41 @@ 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) > - return -1; > +&netdev->tx_ring_ref) == -1) > + return -1; > if (xenstore_read_fe_int(&netdev->xendev, "rx-ring-ref", > - &netdev->rx_ring_ref) == -1) > - return 1; > +&netdev->rx_ring_ref) == -1) > + return 1; > if (xenstore_read_fe_int(&netdev->xendev, "event-channel", > - &netdev->xendev.remote_port) == -1) > - return -1; > +&netdev->xendev.remote_port) == -1) > + return -1; > > if (xenstore_read_fe_int(&netdev->xendev, "request-rx-copy",&rx_copy) == -1) > - rx_copy = 0; > + rx_copy = 0; > if (rx_copy == 0) { > - xen_be_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n"); > - return -1; > + xen_be_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n"); > + return -1; > } > > netdev->txs = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev, > - netdev->xendev.dom, > - netdev->tx_ring_ref, > - PROT_READ | PROT_WRITE); > + netdev->xendev.dom, > + netdev->tx_ring_ref, > + PROT_READ | PROT_WRITE); > netdev->rxs = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev, > - netdev->xendev.dom, > - netdev->rx_ring_ref, > - PROT_READ | PROT_WRITE); > + netdev->xendev.dom, > + netdev->rx_ring_ref, > + PROT_READ | PROT_WRITE); > if (!netdev->txs || !netdev->rxs) > - return -1; > + return -1; > BACK_RING_INIT(&netdev->tx_ring, netdev->txs, XC_PAGE_SIZE); > BACK_RING_INIT(&netdev->rx_ring, netdev->rxs, XC_PAGE_SIZE); > > xen_be_bind_evtchn(&netdev->xendev); > > xen_be_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); > + "remote port %d, local port %d\n", > + netdev->tx_ring_ref, netdev->rx_ring_ref, > + netdev->xendev.remote_port, netdev->xendev.local_port); > > net_tx_packets(netdev); > return 0; > @@ -381,12 +381,12 @@ static void net_disconnect(struct XenDevice *xendev) > xen_be_unbind_evtchn(&netdev->xendev); > > if (netdev->txs) { > - xc_gnttab_munmap(netdev->xendev.gnttabdev, netdev->txs, 1); > - netdev->txs = NULL; > + xc_gnttab_munmap(netdev->xendev.gnttabdev, netdev->txs, 1); > + netdev->txs = NULL; > } > if (netdev->rxs) { > - xc_gnttab_munmap(netdev->xendev.gnttabdev, netdev->rxs, 1); > - netdev->rxs = NULL; > + xc_gnttab_munmap(netdev->xendev.gnttabdev, netdev->rxs, 1); > + netdev->rxs = NULL; > } > if (netdev->nic) { > qemu_del_vlan_client(&netdev->nic->nc); >