From: Anthony Liguori <anthony@codemonkey.ws>
To: anthony.perard@citrix.com
Cc: Xen Devel <xen-devel@lists.xensource.com>,
QEMU-devel <qemu-devel@nongnu.org>,
Stefano Stabellini <stefano.stabellini@eu.citrix.com>
Subject: Re: [Qemu-devel] [PATCH V10 01/15] xen: Replace some tab-indents with spaces (clean-up).
Date: Thu, 24 Feb 2011 10:06:34 -0600 [thread overview]
Message-ID: <4D66820A.4090401@codemonkey.ws> (raw)
In-Reply-To: <1296658172-16609-2-git-send-email-anthony.perard@citrix.com>
On 02/02/2011 08:49 AM, anthony.perard@citrix.com wrote:
> From: Anthony PERARD<anthony.perard@citrix.com>
>
> Signed-off-by: Anthony PERARD<anthony.perard@citrix.com>
> Acked-by: Alexander Graf<agraf@suse.de>
> ---
> 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 = "<unset>";
> - blkdev->filename = blkdev->params;
> - }
> + if (h != NULL) {
> + blkdev->fileproto = blkdev->params;
> + blkdev->filename = h+1;
> + *h = 0;
> + } else {
> + blkdev->fileproto = "<unset>";
> + 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);
>
next prev parent reply other threads:[~2011-02-24 16:09 UTC|newest]
Thread overview: 68+ messages / expand[flat|nested] mbox.gz Atom feed top
2011-02-02 14:49 [Qemu-devel] [PATCH V10 00/15] Xen device model support anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 01/15] xen: Replace some tab-indents with spaces (clean-up) anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-24 16:06 ` Anthony Liguori [this message]
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 02/15] xen: Make xen build only on x86 target anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-24 16:11 ` [Qemu-devel] " Anthony Liguori
2011-02-24 16:25 ` [Xen-devel] " Anthony PERARD
2011-02-24 16:25 ` Anthony PERARD
2011-02-24 17:27 ` [Xen-devel] " Anthony Liguori
2011-02-24 17:27 ` Anthony Liguori
2011-02-24 17:46 ` [Xen-devel] " Jan Kiszka
2011-02-24 17:46 ` Jan Kiszka
2011-02-24 17:59 ` [Xen-devel] " Anthony Liguori
2011-02-24 17:59 ` Anthony Liguori
2011-03-11 6:20 ` [Xen-devel] " Alexander Graf
2011-03-11 6:20 ` Alexander Graf
2011-03-11 11:15 ` [Xen-devel] " Stefano Stabellini
2011-03-11 11:15 ` Stefano Stabellini
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 03/15] xen: Support new libxc calls from xen unstable anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-24 17:29 ` [Qemu-devel] " Anthony Liguori
2011-02-25 14:06 ` [Xen-devel] " Anthony PERARD
2011-02-25 14:06 ` Anthony PERARD
2011-02-25 14:11 ` [Xen-devel] " Anthony Liguori
2011-02-25 14:11 ` Anthony Liguori
2011-02-25 16:01 ` [Xen-devel] " Anthony PERARD
2011-02-25 16:01 ` Anthony PERARD
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 04/15] xen: Add initialisation of Xen anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 05/15] xen: Add xenfv machine anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-24 17:31 ` [Qemu-devel] " Anthony Liguori
2011-02-25 13:55 ` Anthony PERARD
2011-02-25 14:09 ` Anthony Liguori
2011-02-25 14:28 ` [Xen-devel] " Anthony PERARD
2011-02-25 14:28 ` Anthony PERARD
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 06/15] xen: Add the Xen platform pci device anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-24 17:33 ` [Qemu-devel] " Anthony Liguori
2011-02-24 17:36 ` Paolo Bonzini
2011-02-25 9:58 ` [Xen-devel] " Ian Campbell
2011-02-25 9:58 ` Ian Campbell
2011-02-25 10:54 ` Paolo Bonzini
2011-02-25 10:54 ` Paolo Bonzini
2011-02-25 14:18 ` [Xen-devel] " Anthony PERARD
2011-02-25 14:18 ` Anthony PERARD
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 07/15] piix_pci: Introduces Xen specific call for irq anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-24 17:34 ` [Qemu-devel] " Anthony Liguori
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 08/15] xen: Introduce Xen Interrupt Controller anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 09/15] xen: Introduce the Xen mapcache anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 10/15] configure: Always use 64bits target physical addresses with xen enabled anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 11/15] Introduce qemu_put_ram_ptr anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 12/15] vl.c: Introduce getter for shutdown_requested and reset_requested anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 13/15] xen: Initialize event channels and io rings anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 14/15] xen: Set running state in xenstore anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-02 14:49 ` [Qemu-devel] [PATCH V10 15/15] xen: Add Xen hypercall for sleep state in the cmos_s3 callback anthony.perard
2011-02-02 14:49 ` anthony.perard
2011-02-24 17:38 ` [Qemu-devel] [PATCH V10 00/15] Xen device model support Anthony Liguori
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=4D66820A.4090401@codemonkey.ws \
--to=anthony@codemonkey.ws \
--cc=anthony.perard@citrix.com \
--cc=qemu-devel@nongnu.org \
--cc=stefano.stabellini@eu.citrix.com \
--cc=xen-devel@lists.xensource.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.