14 files changed, 59 insertions, 69 deletions

diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 415e79b69d34..8fe61b5dc5a6 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -38,8 +38,8 @@ struct backend_info {
 static struct kmem_cache *xen_blkif_cachep;
 static void connect(struct backend_info *);
 static int connect_ring(struct backend_info *);
-static void backend_changed(struct xenbus_watch *, const char **,
-                            unsigned int);
+static void backend_changed(struct xenbus_watch *, const char *,
+                            const char *);
 static void xen_blkif_free(struct xen_blkif *blkif);
 static void xen_vbd_free(struct xen_vbd *vbd);
 
@@ -661,7 +661,7 @@ fail:
  * ready, connect.
  */
 static void backend_changed(struct xenbus_watch *watch,
-                            const char **vec, unsigned int len)
+                            const char *path, const char *token)
 {
         int err;
         unsigned major;
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index 85b742e1c42f..bb854f92f5a5 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -734,7 +734,7 @@ static int xen_net_read_mac(struct xenbus_device *dev, u8 mac[])
 }
 
 static void xen_net_rate_changed(struct xenbus_watch *watch,
-                                const char **vec, unsigned int len)
+                                 const char *path, const char *token)
 {
         struct xenvif *vif = container_of(watch, struct xenvif, credit_watch);
         struct xenbus_device *dev = xenvif_to_xenbus_device(vif);
@@ -791,7 +791,7 @@ static void xen_unregister_credit_watch(struct xenvif *vif)
 }
 
 static void xen_mcast_ctrl_changed(struct xenbus_watch *watch,
-                                   const char **vec, unsigned int len)
+                                   const char *path, const char *token)
 {
         struct xenvif *vif = container_of(watch, struct xenvif,
                                           mcast_ctrl_watch);
@@ -866,8 +866,8 @@ static void unregister_hotplug_status_watch(struct backend_info *be)
 }
 
 static void hotplug_status_changed(struct xenbus_watch *watch,
-                                   const char **vec,
-                                   unsigned int vec_size)
+                                   const char *path,
+                                   const char *token)
 {
         struct backend_info *be = container_of(watch,
                                                struct backend_info,
diff --git a/drivers/xen/cpu_hotplug.c b/drivers/xen/cpu_hotplug.c
index 0bab60a37464..0003912a8111 100644
--- a/drivers/xen/cpu_hotplug.c
+++ b/drivers/xen/cpu_hotplug.c
@@ -68,13 +68,12 @@ static void vcpu_hotplug(unsigned int cpu)
 }
 
 static void handle_vcpu_hotplug_event(struct xenbus_watch *watch,
-                                        const char **vec, unsigned int len)
+                                      const char *path, const char *token)
 {
         unsigned int cpu;
         char *cpustr;
-        const char *node = vec[XS_WATCH_PATH];
 
-        cpustr = strstr(node, "cpu/");
+        cpustr = strstr(path, "cpu/");
         if (cpustr != NULL) {
                 sscanf(cpustr, "cpu/%u", &cpu);
                 vcpu_hotplug(cpu);
diff --git a/drivers/xen/manage.c b/drivers/xen/manage.c
index 357a8db859c9..c1ec8ee80924 100644
--- a/drivers/xen/manage.c
+++ b/drivers/xen/manage.c
@@ -218,7 +218,7 @@ static struct shutdown_handler shutdown_handlers[] = {
 };
 
 static void shutdown_handler(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len)
+                             const char *path, const char *token)
 {
         char *str;
         struct xenbus_transaction xbt;
@@ -266,8 +266,8 @@ static void shutdown_handler(struct xenbus_watch *watch,
 }
 
 #ifdef CONFIG_MAGIC_SYSRQ
-static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
-                          unsigned int len)
+static void sysrq_handler(struct xenbus_watch *watch, const char *path,
+                          const char *token)
 {
         char sysrq_key = '\0';
         struct xenbus_transaction xbt;
diff --git a/drivers/xen/xen-balloon.c b/drivers/xen/xen-balloon.c
index 79865b8901ba..e7715cb62eef 100644
--- a/drivers/xen/xen-balloon.c
+++ b/drivers/xen/xen-balloon.c
@@ -55,7 +55,7 @@ static int register_balloon(struct device *dev);
 
 /* React to a change in the target key */
 static void watch_target(struct xenbus_watch *watch,
-                         const char **vec, unsigned int len)
+                         const char *path, const char *token)
 {
         unsigned long long new_target;
         int err;
diff --git a/drivers/xen/xen-pciback/xenbus.c b/drivers/xen/xen-pciback/xenbus.c
index 3f0aee0a068b..3814b44bf1f7 100644
--- a/drivers/xen/xen-pciback/xenbus.c
+++ b/drivers/xen/xen-pciback/xenbus.c
@@ -652,7 +652,7 @@ out:
 }
 
 static void xen_pcibk_be_watch(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len)
+                               const char *path, const char *token)
 {
         struct xen_pcibk_device *pdev =
             container_of(watch, struct xen_pcibk_device, be_watch);
diff --git a/drivers/xen/xenbus/xenbus.h b/drivers/xen/xenbus/xenbus.h
index a6b007dfdaa8..51995276f549 100644
--- a/drivers/xen/xenbus/xenbus.h
+++ b/drivers/xen/xenbus/xenbus.h
@@ -40,8 +40,8 @@ struct xen_bus_type {
         int (*get_bus_id)(char bus_id[XEN_BUS_ID_SIZE], const char *nodename);
         int (*probe)(struct xen_bus_type *bus, const char *type,
                      const char *dir);
-        void (*otherend_changed)(struct xenbus_watch *watch, const char **vec,
-                                 unsigned int len);
+        void (*otherend_changed)(struct xenbus_watch *watch, const char *path,
+                                 const char *token);
         struct bus_type bus;
 };
 
@@ -84,7 +84,7 @@ int xenbus_dev_resume(struct device *dev);
 int xenbus_dev_cancel(struct device *dev);
 
 void xenbus_otherend_changed(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len,
+                             const char *path, const char *token,
                              int ignore_on_shutdown);
 
 int xenbus_read_otherend_details(struct xenbus_device *xendev,
diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index 29f82338ab75..82a8866758ee 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -115,7 +115,7 @@ EXPORT_SYMBOL_GPL(xenbus_strstate);
 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
                       struct xenbus_watch *watch,
                       void (*callback)(struct xenbus_watch *,
-                                       const char **, unsigned int))
+                                       const char *, const char *))
 {
         int err;
 
@@ -153,7 +153,7 @@ EXPORT_SYMBOL_GPL(xenbus_watch_path);
 int xenbus_watch_pathfmt(struct xenbus_device *dev,
                          struct xenbus_watch *watch,
                          void (*callback)(struct xenbus_watch *,
-                                        const char **, unsigned int),
+                                          const char *, const char *),
                          const char *pathfmt, ...)
 {
         int err;
diff --git a/drivers/xen/xenbus/xenbus_dev_frontend.c b/drivers/xen/xenbus/xenbus_dev_frontend.c
index e2bc9b301494..e4b984777507 100644
--- a/drivers/xen/xenbus/xenbus_dev_frontend.c
+++ b/drivers/xen/xenbus/xenbus_dev_frontend.c
@@ -258,26 +258,23 @@ out_fail:
 }
 
 static void watch_fired(struct xenbus_watch *watch,
-                        const char **vec,
-                        unsigned int len)
+                        const char *path,
+                        const char *token)
 {
         struct watch_adapter *adap;
         struct xsd_sockmsg hdr;
-        const char *path, *token;
-        int path_len, tok_len, body_len, data_len = 0;
+        const char *token_caller;
+        int path_len, tok_len, body_len;
         int ret;
         LIST_HEAD(staging_q);
 
         adap = container_of(watch, struct watch_adapter, watch);
 
-        path = vec[XS_WATCH_PATH];
-        token = adap->token;
+        token_caller = adap->token;
 
         path_len = strlen(path) + 1;
-        tok_len = strlen(token) + 1;
-        if (len > 2)
-                data_len = vec[len] - vec[2] + 1;
-        body_len = path_len + tok_len + data_len;
+        tok_len = strlen(token_caller) + 1;
+        body_len = path_len + tok_len;
 
         hdr.type = XS_WATCH_EVENT;
         hdr.len = body_len;
@@ -288,9 +285,7 @@ static void watch_fired(struct xenbus_watch *watch,
         if (!ret)
                 ret = queue_reply(&staging_q, path, path_len);
         if (!ret)
-                ret = queue_reply(&staging_q, token, tok_len);
-        if (!ret && len > 2)
-                ret = queue_reply(&staging_q, vec[2], data_len);
+                ret = queue_reply(&staging_q, token_caller, tok_len);
 
         if (!ret) {
                 /* success: pass reply list onto watcher */
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 6baffbb6acf9..74888cacd0b0 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -169,7 +169,7 @@ int xenbus_read_otherend_details(struct xenbus_device *xendev,
 EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);
 
 void xenbus_otherend_changed(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len,
+                             const char *path, const char *token,
                              int ignore_on_shutdown)
 {
         struct xenbus_device *dev =
@@ -180,18 +180,15 @@ void xenbus_otherend_changed(struct xenbus_watch *watch,
         /* Protect us against watches firing on old details when the otherend
            details change, say immediately after a resume. */
         if (!dev->otherend ||
-            strncmp(dev->otherend, vec[XS_WATCH_PATH],
-                    strlen(dev->otherend))) {
-                dev_dbg(&dev->dev, "Ignoring watch at %s\n",
-                        vec[XS_WATCH_PATH]);
+            strncmp(dev->otherend, path, strlen(dev->otherend))) {
+                dev_dbg(&dev->dev, "Ignoring watch at %s\n", path);
                 return;
         }
 
         state = xenbus_read_driver_state(dev->otherend);
 
         dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n",
-                state, xenbus_strstate(state), dev->otherend_watch.node,
-                vec[XS_WATCH_PATH]);
+                state, xenbus_strstate(state), dev->otherend_watch.node, path);
 
         /*
          * Ignore xenbus transitions during shutdown. This prevents us doing
diff --git a/drivers/xen/xenbus/xenbus_probe_backend.c b/drivers/xen/xenbus/xenbus_probe_backend.c
index f46b4dc72c76..b0bed4faf44c 100644
--- a/drivers/xen/xenbus/xenbus_probe_backend.c
+++ b/drivers/xen/xenbus/xenbus_probe_backend.c
@@ -181,9 +181,9 @@ static int xenbus_probe_backend(struct xen_bus_type *bus, const char *type,
 }
 
 static void frontend_changed(struct xenbus_watch *watch,
-                            const char **vec, unsigned int len)
+                             const char *path, const char *token)
 {
-        xenbus_otherend_changed(watch, vec, len, 0);
+        xenbus_otherend_changed(watch, path, token, 0);
 }
 
 static struct xen_bus_type xenbus_backend = {
@@ -204,11 +204,11 @@ static struct xen_bus_type xenbus_backend = {
 };
 
 static void backend_changed(struct xenbus_watch *watch,
-                            const char **vec, unsigned int len)
+                            const char *path, const char *token)
 {
         DPRINTK("");
 
-        xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_backend);
+        xenbus_dev_changed(path, &xenbus_backend);
 }
 
 static struct xenbus_watch be_watch = {
diff --git a/drivers/xen/xenbus/xenbus_probe_frontend.c b/drivers/xen/xenbus/xenbus_probe_frontend.c
index d7b77a62e6e7..19e45ce21f89 100644
--- a/drivers/xen/xenbus/xenbus_probe_frontend.c
+++ b/drivers/xen/xenbus/xenbus_probe_frontend.c
@@ -86,9 +86,9 @@ static int xenbus_uevent_frontend(struct device *_dev,
 
 
 static void backend_changed(struct xenbus_watch *watch,
-                            const char **vec, unsigned int len)
+                            const char *path, const char *token)
 {
-        xenbus_otherend_changed(watch, vec, len, 1);
+        xenbus_otherend_changed(watch, path, token, 1);
 }
 
 static void xenbus_frontend_delayed_resume(struct work_struct *w)
@@ -153,11 +153,11 @@ static struct xen_bus_type xenbus_frontend = {
 };
 
 static void frontend_changed(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len)
+                             const char *path, const char *token)
 {
         DPRINTK("");
 
-        xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
+        xenbus_dev_changed(path, &xenbus_frontend);
 }
 
 
@@ -332,13 +332,13 @@ static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq);
 static int backend_state;
 
 static void xenbus_reset_backend_state_changed(struct xenbus_watch *w,
-                                        const char **v, unsigned int l)
+                                        const char *path, const char *token)
 {
-        if (xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i",
+        if (xenbus_scanf(XBT_NIL, path, "", "%i",
                          &backend_state) != 1)
                 backend_state = XenbusStateUnknown;
         printk(KERN_DEBUG "XENBUS: backend %s %s\n",
-                        v[XS_WATCH_PATH], xenbus_strstate(backend_state));
+               path, xenbus_strstate(backend_state));
         wake_up(&backend_state_wq);
 }
 
diff --git a/drivers/xen/xenbus/xenbus_xs.c b/drivers/xen/xenbus/xenbus_xs.c
index 4c49d8709765..ebc768f44abe 100644
--- a/drivers/xen/xenbus/xenbus_xs.c
+++ b/drivers/xen/xenbus/xenbus_xs.c
@@ -64,8 +64,8 @@ struct xs_stored_msg {
                 /* Queued watch events. */
                 struct {
                         struct xenbus_watch *handle;
-                        char **vec;
-                        unsigned int vec_size;
+                        const char *path;
+                        const char *token;
                 } watch;
         } u;
 };
@@ -765,7 +765,7 @@ void unregister_xenbus_watch(struct xenbus_watch *watch)
                 if (msg->u.watch.handle != watch)
                         continue;
                 list_del(&msg->list);
-                kfree(msg->u.watch.vec);
+                kfree(msg->u.watch.path);
                 kfree(msg);
         }
         spin_unlock(&watch_events_lock);
@@ -833,11 +833,10 @@ static int xenwatch_thread(void *unused)
 
                 if (ent != &watch_events) {
                         msg = list_entry(ent, struct xs_stored_msg, list);
-                        msg->u.watch.handle->callback(
-                                msg->u.watch.handle,
-                                (const char **)msg->u.watch.vec,
-                                msg->u.watch.vec_size);
-                        kfree(msg->u.watch.vec);
+                        msg->u.watch.handle->callback(msg->u.watch.handle,
+                                                      msg->u.watch.path,
+                                                      msg->u.watch.token);
+                        kfree(msg->u.watch.path);
                         kfree(msg);
                 }
 
@@ -903,24 +902,24 @@ static int process_msg(void)
         body[msg->hdr.len] = '\0';
 
         if (msg->hdr.type == XS_WATCH_EVENT) {
-                msg->u.watch.vec = split(body, msg->hdr.len,
-                                         &msg->u.watch.vec_size);
-                if (IS_ERR(msg->u.watch.vec)) {
-                        err = PTR_ERR(msg->u.watch.vec);
+                if (count_strings(body, msg->hdr.len) != 2) {
+                        err = -EINVAL;
                         kfree(msg);
+                        kfree(body);
                         goto out;
                 }
+                msg->u.watch.path = (const char *)body;
+                msg->u.watch.token = (const char *)strchr(body, '\0') + 1;
 
                 spin_lock(&watches_lock);
-                msg->u.watch.handle = find_watch(
-                        msg->u.watch.vec[XS_WATCH_TOKEN]);
+                msg->u.watch.handle = find_watch(msg->u.watch.token);
                 if (msg->u.watch.handle != NULL) {
                         spin_lock(&watch_events_lock);
                         list_add_tail(&msg->list, &watch_events);
                         wake_up(&watch_events_waitq);
                         spin_unlock(&watch_events_lock);
                 } else {
-                        kfree(msg->u.watch.vec);
+                        kfree(body);
                         kfree(msg);
                 }
                 spin_unlock(&watches_lock);
diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
index 98f73a20725c..869c816d5f8c 100644
--- a/include/xen/xenbus.h
+++ b/include/xen/xenbus.h
@@ -61,7 +61,7 @@ struct xenbus_watch
 
         /* Callback (executed in a process context with no locks held). */
         void (*callback)(struct xenbus_watch *,
-                         const char **vec, unsigned int len);
+                         const char *path, const char *token);
 };
 
 
@@ -193,11 +193,11 @@ void xenbus_probe(struct work_struct *);
 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
                       struct xenbus_watch *watch,
                       void (*callback)(struct xenbus_watch *,
-                                       const char **, unsigned int));
+                                       const char *, const char *));
 __printf(4, 5)
 int xenbus_watch_pathfmt(struct xenbus_device *dev, struct xenbus_watch *watch,
                          void (*callback)(struct xenbus_watch *,
-                                          const char **, unsigned int),
+                                          const char *, const char *),
                          const char *pathfmt, ...);
 
 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state new_state);