1 files changed, 66 insertions, 24 deletions

diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index 7b3e973a1aee..7e49527189b6 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -133,17 +133,12 @@ int xenbus_watch_pathfmt(struct xenbus_device *dev,
 }
 EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
 
+static void xenbus_switch_fatal(struct xenbus_device *, int, int,
+                                const char *, ...);
 
-/**
- * xenbus_switch_state
- * @dev: xenbus device
- * @state: new state
- *
- * Advertise in the store a change of the given driver to the given new_state.
- * Return 0 on success, or -errno on error.  On error, the device will switch
- * to XenbusStateClosing, and the error will be saved in the store.
- */
-int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
+static int
+__xenbus_switch_state(struct xenbus_device *dev,
+                      enum xenbus_state state, int depth)
 {
         /* We check whether the state is currently set to the given value, and
            if not, then the state is set.  We don't want to unconditionally
@@ -152,35 +147,65 @@ int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
            to it, as the device will be tearing down, and we don't want to
            resurrect that directory.
 
-           Note that, because of this cached value of our state, this function
-           will not work inside a Xenstore transaction (something it was
-           trying to in the past) because dev->state would not get reset if
-           the transaction was aborted.
-
+           Note that, because of this cached value of our state, this
+           function will not take a caller's Xenstore transaction
+           (something it was trying to in the past) because dev->state
+           would not get reset if the transaction was aborted.
          */
 
+        struct xenbus_transaction xbt;
         int current_state;
-        int err;
+        int err, abort;
 
         if (state == dev->state)
                 return 0;
 
-        err = xenbus_scanf(XBT_NIL, dev->nodename, "state", "%d",
-                           &current_state);
-        if (err != 1)
+again:
+        abort = 1;
+
+        err = xenbus_transaction_start(&xbt);
+        if (err) {
+                xenbus_switch_fatal(dev, depth, err, "starting transaction");
                 return 0;
+        }
+
+        err = xenbus_scanf(xbt, dev->nodename, "state", "%d", &current_state);
+        if (err != 1)
+                goto abort;
 
-        err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%d", state);
+        err = xenbus_printf(xbt, dev->nodename, "state", "%d", state);
         if (err) {
-                if (state != XenbusStateClosing) /* Avoid looping */
-                        xenbus_dev_fatal(dev, err, "writing new state");
-                return err;
+                xenbus_switch_fatal(dev, depth, err, "writing new state");
+                goto abort;
         }
 
-        dev->state = state;
+        abort = 0;
+abort:
+        err = xenbus_transaction_end(xbt, abort);
+        if (err) {
+                if (err == -EAGAIN && !abort)
+                        goto again;
+                xenbus_switch_fatal(dev, depth, err, "ending transaction");
+        } else
+                dev->state = state;
 
         return 0;
 }
+
+/**
+ * xenbus_switch_state
+ * @dev: xenbus device
+ * @state: new state
+ *
+ * Advertise in the store a change of the given driver to the given new_state.
+ * Return 0 on success, or -errno on error.  On error, the device will switch
+ * to XenbusStateClosing, and the error will be saved in the store.
+ */
+int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
+{
+        return __xenbus_switch_state(dev, state, 0);
+}
+
 EXPORT_SYMBOL_GPL(xenbus_switch_state);
 
 int xenbus_frontend_closed(struct xenbus_device *dev)
@@ -284,6 +309,23 @@ void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...)
 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
 
 /**
+ * Equivalent to xenbus_dev_fatal(dev, err, fmt, args), but helps
+ * avoiding recursion within xenbus_switch_state.
+ */
+static void xenbus_switch_fatal(struct xenbus_device *dev, int depth, int err,
+                                const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        xenbus_va_dev_error(dev, err, fmt, ap);
+        va_end(ap);
+
+        if (!depth)
+                __xenbus_switch_state(dev, XenbusStateClosing, 1);
+}
+
+/**
  * xenbus_grant_ring
  * @dev: xenbus device
  * @ring_mfn: mfn of ring to grant