WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-devel

[Xen-devel] Re: [Qemu-devel] [PATCH V10 01/15] xen: Replace some tab-ind

To: anthony.perard@xxxxxxxxxx
Subject: [Xen-devel] Re: [Qemu-devel] [PATCH V10 01/15] xen: Replace some tab-indents with spaces (clean-up).
From: Anthony Liguori <anthony@xxxxxxxxxxxxx>
Date: Thu, 24 Feb 2011 10:06:34 -0600
Cc: Xen Devel <xen-devel@xxxxxxxxxxxxxxxxxxx>, QEMU-devel <qemu-devel@xxxxxxxxxx>, Stefano Stabellini <stefano.stabellini@xxxxxxxxxxxxx>
Delivery-date: Thu, 24 Feb 2011 08:09:47 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxxx
In-reply-to: <1296658172-16609-2-git-send-email-anthony.perard@xxxxxxxxxx>
List-help: <mailto:xen-devel-request@lists.xensource.com?subject=help>
List-id: Xen developer discussion <xen-devel.lists.xensource.com>
List-post: <mailto:xen-devel@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=unsubscribe>
References: <1296658172-16609-1-git-send-email-anthony.perard@xxxxxxxxxx> <1296658172-16609-2-git-send-email-anthony.perard@xxxxxxxxxx>
Sender: xen-devel-bounces@xxxxxxxxxxxxxxxxxxx
User-agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.15) Gecko/20101027 Lightning/1.0b1 Thunderbird/3.0.10
On 02/02/2011 08:49 AM, anthony.perard@xxxxxxxxxx wrote:
From: Anthony PERARD<anthony.perard@xxxxxxxxxx>

Signed-off-by: Anthony PERARD<anthony.perard@xxxxxxxxxx>
Acked-by: Alexander Graf<agraf@xxxxxxx>
---
  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);


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel

<Prev in Thread] Current Thread [Next in Thread>