xen: modify xenstore watch event interface

Today a Xenstore watch event is delivered via a callback function
declared as:

void (*callback)(struct xenbus_watch *,
                 const char **vec, unsigned int len);

As all watch events only ever come with two parameters (path and token)
changing the prototype to:

void (*callback)(struct xenbus_watch *,
                 const char *path, const char *token);

is the natural thing to do.

Apply this change and adapt all users.

Cc: konrad.wilk@oracle.com
Cc: roger.pau@citrix.com
Cc: wei.liu2@citrix.com
Cc: paul.durrant@citrix.com
Cc: netdev@vger.kernel.org
Signed-off-by: Juergen Gross <jgross@suse.com>
Reviewed-by: Paul Durrant <paul.durrant@citrix.com>
Reviewed-by: Wei Liu <wei.liu2@citrix.com>
Reviewed-by: Roger Pau Monné <roger.pau@citrix.com>
Reviewed-by: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Signed-off-by: Boris Ostrovsky <boris.ostrovsky@oracle.com>

diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 415e79b69d347b207f4e1caeecc7e4ce482356d4..8fe61b5dc5a6553d141950506344fe90bbfde2c8 100644 (file)
--- 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 85b742e1c42fa75bc771db4e8b91f80f3fe68d75..bb854f92f5a5cd4a531082cf04cf28c0f6801c42 100644 (file)
--- 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 0bab60a374648380e763aca385551d80aeaf3843..0003912a8111959a101803f52ed8be80f4ae2f30 100644 (file)
--- 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 357a8db859c9889755099fe406ecada93e94f220..c1ec8ee80924837914ecc0fb2f3ca09cfd00bbcc 100644 (file)
--- 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 79865b8901baa29cf9427eb2237fad364c44bb31..e7715cb62eefc307a354a77902baaaa5916a157c 100644 (file)
--- 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 3f0aee0a068b213803b4a4a3a771c1285562b43e..3814b44bf1f76e2dc16964c557f731315a4c8876 100644 (file)
--- 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 a6b007dfdaa8ff44cf76cda397f368e19fc845f7..51995276f5496c907a1e8455de582ea59ced4f73 100644 (file)
--- 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 29f82338ab75533763e80c4b5d1c491caac93251..82a8866758ee0d5ac235430059f74a7bb56b09f8 100644 (file)
--- 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 e2bc9b301494e07eda5b85728782fd9b09df9239..e4b98477750771e52cf6d53d45810321e22dbaeb 100644 (file)
--- 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 6baffbb6acf97c511f612a88840baa2038e8e1e4..74888cacd0b0bdcd250135e6436e0c1e39fc330f 100644 (file)
--- 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 f46b4dc72c7652f87f65de6f4fa747f7a766646f..b0bed4faf44cc85a918a4fdb8a3929b846c13ec8 100644 (file)
--- 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 d7b77a62e6e7843c759eae451810492fe8ebd68d..19e45ce21f891e19dc82e01e30cc5aedeb79a951 100644 (file)
--- 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 4c49d870976577652ca2554cbdf1a6e21c339580..ebc768f44abe56f2f6d32b66e668b79a77941a91 100644 (file)
--- 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 98f73a20725c73ba4e914c583de808ae9fb283ec..869c816d5f8c3097b09298a9d086e7f75fff540e 100644 (file)
--- 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);