|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-changelog] Major xenbus cleanup
# HG changeset patch
# User cl349@xxxxxxxxxxxxxxxxxxxx
# Node ID 2e6e1eb66c5e51759ffcb04f95cb3ffa1f1cf4f2
# Parent 62e13cae2f5861169c9102241fbfeca25681f602
Major xenbus cleanup
1) Make xenbus_* functions first-class citizens, evict xs_ prefix.
2) Add xenbus_scanf and xenbus_printf instead of multiple functions
3) Remove unused code from xenbus.c
4) Use standard debugging macros.
Signed-off-by: Rusty Russel <rusty@xxxxxxxxxxxxxxx>
Signed-off-by: Christian Limpach <Christian.Limpach@xxxxxxxxxxxx>
diff -r 62e13cae2f58 -r 2e6e1eb66c5e
linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c
--- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c Tue Jul 26
15:57:18 2005
+++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_probe.c Tue Jul 26
16:59:40 2005
@@ -26,6 +26,8 @@
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
+#define DEBUG
+
#include <asm-xen/hypervisor.h>
#include <asm-xen/xenbus.h>
#include <linux/kernel.h>
@@ -39,148 +41,9 @@
/* Name of field containing device type. */
#define XENBUS_DEVICE_TYPE "type"
-#define DEBUG
-
-#ifdef DEBUG
-#define dprintf(_fmt, _args...) \
-printk(KERN_INFO __stringify(KBUILD_MODNAME) " [DBG] %s" _fmt,
__FUNCTION__, ##_args)
-#else
-#define dprintf(_fmt, _args...) do { } while(0)
-#endif
-
static int xs_init_done = 0;
-/* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
-int xenbus_gather(const char *dir, ...)
-{
- va_list ap;
- const char *name;
- int ret = 0;
-
- va_start(ap, dir);
- while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
- const char *fmt = va_arg(ap, char *);
- void *result = va_arg(ap, void *);
- char *p;
-
- p = xenbus_read(dir, name, NULL);
- if (IS_ERR(p)) {
- ret = PTR_ERR(p);
- break;
- }
- if (sscanf(p, fmt, result) == 0)
- ret = -EINVAL;
- kfree(p);
- }
- va_end(ap);
- return ret;
-}
-
-/* Return the path to dir with /name appended.
- * If name is null or empty returns a copy of dir.
- */
-char *xenbus_path(const char *dir, const char *name)
-{
- char *ret;
- int len;
-
- len = strlen(dir) + 1;
- if (name)
- len += strlen(name) + 1;
- ret = kmalloc(len, GFP_KERNEL);
- if (ret == NULL)
- return NULL;
- strcpy(ret, dir);
- if (name) {
- strcat(ret, "/");
- strcat(ret, name);
- }
- return ret;
-}
-
#define streq(a, b) (strcmp((a), (b)) == 0)
-
-char *xenbus_read(const char *dir, const char *name, unsigned int *data_n)
-{
- int err = 0;
- char *data = NULL;
- char *path = xenbus_path(dir, name);
- int n = 0;
-
- if (!path) {
- err = -ENOMEM;
- goto out;
- }
- data = xs_read(path, &n);
- if (IS_ERR(data)) {
- err = PTR_ERR(data);
- if (err == -EISDIR)
- err = -ENOENT;
- } else if (n == 0) {
- err = -ENOENT;
- kfree(data);
- }
- kfree(path);
- out:
- if (data_n)
- *data_n = n;
- return (err ? ERR_PTR(err) : data);
-}
-
-int xenbus_write(const char *dir, const char *name, const char *data, int
data_n)
-{
- int err = 0;
- char *path = xenbus_path(dir, name);
-
- if (!path)
- return -ENOMEM;
- err = xs_write(path, data, data_n, O_CREAT);
- kfree(path);
- return err;
-}
-
-int xenbus_read_string(const char *dir, const char *name, char **val)
-{
- int err = 0;
-
- *val = xenbus_read(dir, name, NULL);
- if (IS_ERR(*val)) {
- err = PTR_ERR(*val);
- *val = NULL;
- }
- return err;
-}
-
-int xenbus_write_string(const char *dir, const char *name, const char *val)
-{
- return xenbus_write(dir, name, val, strlen(val));
-}
-
-int xenbus_read_ulong(const char *dir, const char *name, unsigned long *val)
-{
- return xenbus_gather(dir, name, "%lu", val, NULL);
-}
-
-int xenbus_write_ulong(const char *dir, const char *name, unsigned long val)
-{
- char data[32] = {};
-
- snprintf(data, sizeof(data), "%lu", val);
- return xenbus_write(dir, name, data, strlen(data));
-}
-
-int xenbus_read_long(const char *dir, const char *name, long *val)
-{
- return xenbus_gather(dir, name, "%li", val, NULL);
-}
-
-int xenbus_write_long(const char *dir, const char *name, long val)
-{
- char data[32] = {};
-
- snprintf(data, sizeof(data), "%li", val);
- return xenbus_write(dir, name, data, strlen(data));
-}
/* If something in array of ids matches this device, return it. */
static const struct xenbus_device_id *
@@ -214,68 +77,6 @@
.match = xenbus_match,
};
-
-/* Bus type for backend drivers. */
-static struct bus_type xenback_type = {
- .name = "xenback",
- .match = xenbus_match,
-};
-
-struct xenbus_for_dev {
- int (*fn)(struct xenbus_device *, void *);
- void *data;
-};
-
-static int for_dev(struct device *_dev, void *_data)
-{
- struct xenbus_device *dev = to_xenbus_device(_dev);
- struct xenbus_for_dev *data = _data;
- dev = to_xenbus_device(_dev);
- return data->fn(dev, data->data);
-}
-
-int xenbus_for_each_dev(struct xenbus_device * start, void * data,
- int (*fn)(struct xenbus_device *, void *))
-{
- struct xenbus_for_dev for_data = {
- .fn = fn,
- .data = data,
- };
- if (!fn)
- return -EINVAL;
- printk("%s> data=%p fn=%p for_data=%p\n", __FUNCTION__,
- data, fn, &for_data);
- return bus_for_each_dev(&xenbus_type,
- (start ? &start->dev : NULL),
- &for_data, for_dev);
-}
-
-struct xenbus_for_drv {
- int (*fn)(struct xenbus_driver *, void *);
- void *data;
-};
-
-static int for_drv(struct device_driver *_drv, void *_data)
-{
- struct xenbus_driver *drv = to_xenbus_driver(_drv);
- struct xenbus_for_drv *data = _data;
- return data->fn(drv, data->data);
-}
-
-int xenbus_for_each_drv(struct xenbus_driver * start, void * data,
- int (*fn)(struct xenbus_driver *, void *))
-{
- struct xenbus_for_drv for_data = {
- .fn = fn,
- .data = data,
- };
- if (!fn)
- return -EINVAL;
- return bus_for_each_drv(&xenbus_type,
- (start ? &start->driver: NULL),
- &for_data, for_drv);
-}
-
static int xenbus_dev_probe(struct device *_dev)
{
struct xenbus_device *dev = to_xenbus_device(_dev);
@@ -309,23 +110,13 @@
int xenbus_register_driver(struct xenbus_driver *drv)
{
- int err = 0;
-
- printk("%s> frontend driver %p %s\n", __FUNCTION__,
- drv, drv->name);
drv->driver.name = drv->name;
drv->driver.bus = &xenbus_type;
drv->driver.owner = drv->owner;
drv->driver.probe = xenbus_dev_probe;
drv->driver.remove = xenbus_dev_remove;
- err = driver_register(&drv->driver);
- if (err == 0 && xs_init_done && drv->connect) {
- printk("%s> connecting driver %p %s\n", __FUNCTION__,
- drv, drv->name);
- drv->connect(drv);
- }
- return err;
+ return driver_register(&drv->driver);
}
void xenbus_unregister_driver(struct xenbus_driver *drv)
@@ -333,39 +124,36 @@
driver_unregister(&drv->driver);
}
-static int xenbus_probe_device(const char *dir, const char *name, const char
*devicetype)
+/* devices/<typename>/<name> */
+static int xenbus_probe_device(const char *typename, const char *name)
{
int err;
struct xenbus_device *xendev;
- unsigned int xendev_n;
- char *nodename;
-
- dprintf("> dir=%s name=%s\n", dir, name);
- nodename = xenbus_path(dir, name);
- if (!nodename)
+ unsigned int stringlen;
+
+ pr_debug("> dir=%s name=%s\n", typename, name);
+
+ /* FIXME: This could be a rescan. Don't re-register existing devices. */
+
+ /* Nodename: /device/<typename>/<name>/ */
+ stringlen = strlen("device") + strlen(typename) + strlen(name) + 3;
+ /* Typename */
+ stringlen += strlen(typename) + 1;
+
+ xendev = kmalloc(sizeof(*xendev) + stringlen, GFP_KERNEL);
+ if (!xendev)
return -ENOMEM;
- /* FIXME: This could be a rescan. Don't re-register existing devices. */
-
- /* Add space for the strings. */
- xendev_n = sizeof(*xendev) + strlen(nodename) + strlen(devicetype) + 2;
- xendev = kmalloc(xendev_n, GFP_KERNEL);
- if (!xendev) {
- err = -ENOMEM;
- goto free_nodename;
- }
- memset(xendev, 0, xendev_n);
-
- snprintf(xendev->dev.bus_id, BUS_ID_SIZE, "%s-%s", devicetype, name);
- xendev->dev.bus = &xenbus_type;
-
- xendev->id = simple_strtol(name, NULL, 0);
-
+ memset(xendev, 0, sizeof(*xendev));
/* Copy the strings into the extra space. */
xendev->nodename = (char *)(xendev + 1);
- strcpy(xendev->nodename, nodename);
+ sprintf(xendev->nodename, "%s/%s/%s", "device", typename, name);
xendev->devicetype = xendev->nodename + strlen(xendev->nodename) + 1;
- strcpy(xendev->devicetype, devicetype);
+ strcpy(xendev->devicetype, typename);
+
+ /* FIXME: look for "subtype" field. */
+ snprintf(xendev->dev.bus_id, BUS_ID_SIZE, "%s-%s", typename, name);
+ xendev->dev.bus = &xenbus_type;
/* Register with generic device framework. */
printk("XENBUS: Registering device %s\n", xendev->dev.bus_id);
@@ -376,203 +164,61 @@
kfree(xendev);
}
-free_nodename:
- kfree(nodename);
- dprintf("< err=%i\n", err);
- return err;
-}
-
-static int xenbus_probe_device_type(const char *dirpath, const char *typename)
+ pr_debug("< err=%i\n", err);
+ return err;
+}
+
+/* /device/<typename> */
+static int xenbus_probe_device_type(const char *typename)
{
int err = 0;
char **dir;
- char *path;
unsigned int dir_n = 0;
int i;
- dprintf("> dirpath=%s typename=%s\n", dirpath, typename);
- path = xenbus_path(dirpath, typename);
- if (!path)
- return -ENOMEM;
-
- dir = xs_directory(path, &dir_n);
+ dir = xenbus_directory("device", typename, &dir_n);
+ printk("dir %s has %u entries\n", typename, dir_n);
if (IS_ERR(dir)) {
- err = PTR_ERR(dir);
- goto out;
+ printk("dir %s returned %li\n", typename, PTR_ERR(dir));
+ return PTR_ERR(dir);
}
for (i = 0; i < dir_n; i++) {
- err = xenbus_probe_device(path, dir[i], typename);
+ printk("Probing %s/%s\n", dir[i], typename);
+ err = xenbus_probe_device(dir[i], typename);
if (err)
break;
}
kfree(dir);
-out:
- kfree(path);
- dprintf("< err=%i\n", err);
- return err;
-}
-
-static int xenbus_probe_devices(const char *path)
+ pr_debug("< err=%i\n", err);
+ return err;
+}
+
+static int xenbus_probe_devices(void)
{
int err = 0;
char **dir;
unsigned int i, dir_n;
- dprintf("> path=%s\n", path);
- down(&xs_lock);
- dir = xs_directory(path, &dir_n);
+ down(&xenbus_lock);
+ dir = xenbus_directory("device", "", &dir_n);
if (IS_ERR(dir)) {
err = PTR_ERR(dir);
goto unlock;
}
for (i = 0; i < dir_n; i++) {
- err = xenbus_probe_device_type(path, dir[i]);
- if (err)
+ err = xenbus_probe_device_type(dir[i]);
+ if (err) {
+ printk("xenbus: error %i probing device %s\n",
+ -err, dir[i]);
break;
+ }
}
kfree(dir);
unlock:
- up(&xs_lock);
- dprintf("< err=%i\n", err);
- return err;
-}
-
-
-static int xenbus_probe_backend(const char *dir, const char *name)
-{
- int err = 0;
- struct xenbus_device *xendev = NULL;
- unsigned int xendev_n = 0;
- char *nodename = NULL, *devicetype = NULL;
- unsigned int devicetype_n = 0;
-
- dprintf("> dir=%s name=%s\n", dir, name);
- nodename = xenbus_path(dir, name);
- if (!nodename)
- return -ENOMEM;
-
- devicetype = xenbus_read(nodename, XENBUS_DEVICE_TYPE, &devicetype_n);
- if (IS_ERR(devicetype)) {
- err = PTR_ERR(devicetype);
- goto free_nodename;
- }
-
- dprintf("> devicetype='%s'\n", devicetype);
- /* FIXME: This could be a rescan. Don't re-register existing devices. */
-
- /* Add space for the strings. */
- xendev_n = sizeof(*xendev) + strlen(nodename) + strlen(devicetype) + 2;
- xendev = kmalloc(xendev_n, GFP_KERNEL);
- if (!xendev) {
- err = -ENOMEM;
- goto free_devicetype;
- }
- memset(xendev, 0, xendev_n);
-
- snprintf(xendev->dev.bus_id, BUS_ID_SIZE, "%s", devicetype);
- xendev->dev.bus = &xenback_type;
-
- /* Copy the strings into the extra space. */
- xendev->nodename = (char *)(xendev + 1);
- strcpy(xendev->nodename, nodename);
- xendev->devicetype = xendev->nodename + strlen(xendev->nodename) + 1;
- strcpy(xendev->devicetype, devicetype);
-
- /* Register with generic device framework. */
- printk("XENBUS: Registering backend %s\n", xendev->dev.bus_id);
- err = device_register(&xendev->dev);
- if (err) {
- printk("XENBUS: Registering device %s: error %i\n",
- xendev->dev.bus_id, err);
- kfree(xendev);
- }
-
-free_devicetype:
- kfree(devicetype);
-free_nodename:
- kfree(nodename);
- dprintf("< err=%i\n", err);
- return err;
-}
-
-static int xenbus_probe_backends(const char *path)
-{
- int err = 0;
- char **dir;
- unsigned int i, dir_n;
-
- dprintf("> path=%s\n", path);
- down(&xs_lock);
- dir = xs_directory(path, &dir_n);
- if (IS_ERR(dir)) {
- err = PTR_ERR(dir);
- goto unlock;
- }
- for (i = 0; i < dir_n; i++) {
- err = xenbus_probe_backend(path, dir[i]);
- if (err)
- break;
- }
- kfree(dir);
-unlock:
- up(&xs_lock);
- dprintf("< err=%i\n", err);
- return err;
-}
-
-int xenbus_register_backend(struct xenbus_driver *drv)
-{
- int err = 0;
-
- printk("%s> backend driver %p %s\n", __FUNCTION__,
- drv, drv->name);
- drv->driver.name = drv->name;
- drv->driver.bus = &xenback_type;
- drv->driver.owner = drv->owner;
- drv->driver.probe = xenbus_dev_probe;
- drv->driver.remove = xenbus_dev_remove;
-
- err = driver_register(&drv->driver);
- if (err == 0 && xs_init_done && drv->connect) {
- printk("%s> connecting driver %p %s\n", __FUNCTION__,
- drv, drv->name);
- drv->connect(drv);
- }
- return err;
-}
-
-void xenbus_unregister_backend(struct xenbus_driver *drv)
-{
- driver_unregister(&drv->driver);
-}
-
-int xenbus_for_each_backend(struct xenbus_driver * start, void * data,
- int (*fn)(struct xenbus_driver *, void *))
-{
- struct xenbus_for_drv for_data = {
- .fn = fn,
- .data = data,
- };
- if (!fn)
- return -EINVAL;
- return bus_for_each_drv(&xenback_type,
- (start ? &start->driver: NULL),
- &for_data, for_drv);
-}
-
-static int xenbus_driver_connect(struct xenbus_driver *drv, void *data)
-{
- printk("%s> driver %p %s\n", __FUNCTION__, drv, drv->name);
- if (drv->connect) {
- printk("%s> connecting driver %p %s\n", __FUNCTION__,
- drv, drv->name);
- drv->connect(drv);
- }
- printk("%s< driver %p %s\n", __FUNCTION__, drv, drv->name);
- return 0;
-}
-
+ up(&xenbus_lock);
+ return err;
+}
/* called from a thread in privcmd/privcmd.c */
int do_xenbus_probe(void *unused)
@@ -592,15 +238,8 @@
}
xs_init_done = 1;
- /* Notify drivers that xenstore has connected. */
- printk("%s> connect drivers...\n", __FUNCTION__);
- xenbus_for_each_drv(NULL, NULL, xenbus_driver_connect);
- printk("%s> connect backends...\n", __FUNCTION__);
- xenbus_for_each_backend(NULL, NULL, xenbus_driver_connect);
-
- /* Enumerate devices and backends in xenstore. */
- xenbus_probe_devices("device");
- xenbus_probe_backends("backend");
+ /* Enumerate devices in xenstore. */
+ xenbus_probe_devices();
exit:
printk("%s< err=%d\n", __FUNCTION__, err);
@@ -610,7 +249,6 @@
static int __init xenbus_probe_init(void)
{
bus_register(&xenbus_type);
- bus_register(&xenback_type);
if (!xen_start_info.store_evtchn)
return 0;
diff -r 62e13cae2f58 -r 2e6e1eb66c5e
linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_xs.c
--- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_xs.c Tue Jul 26
15:57:18 2005
+++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_xs.c Tue Jul 26
16:59:40 2005
@@ -2,7 +2,7 @@
* xenbus_xs.c
*
* This is the kernel equivalent of the "xs" library. We don't need everything
- * and we use xenbus_comms to communication.
+ * and we use xenbus_comms for communication.
*
* Copyright (C) 2005 Rusty Russell, IBM Corporation
*
@@ -45,7 +45,7 @@
static void *xs_in, *xs_out;
static LIST_HEAD(watches);
-DECLARE_MUTEX(xs_lock);
+DECLARE_MUTEX(xenbus_lock);
static int get_error(const char *errorstring)
{
@@ -90,7 +90,7 @@
}
/* Emergency write. */
-void xs_debug_write(const char *str, unsigned int count)
+void xenbus_debug_write(const char *str, unsigned int count)
{
struct xsd_sockmsg msg;
void *out = (void *)xen_start_info.store_page;
@@ -115,7 +115,7 @@
unsigned int i;
int err;
- WARN_ON(down_trylock(&xs_lock) == 0);
+ WARN_ON(down_trylock(&xenbus_lock) == 0);
msg.type = type;
msg.len = 0;
@@ -182,12 +182,28 @@
return num;
}
-char **xs_directory(const char *path, unsigned int *num)
+/* Return the path to dir with /name appended. */
+static char *join(const char *dir, const char *name)
+{
+ static char buffer[4096];
+
+ BUG_ON(down_trylock(&xenbus_lock) == 0);
+ BUG_ON(strlen(dir) + strlen("/") + strlen(name) + 1 > sizeof(buffer));
+
+ strcpy(buffer, dir);
+ if (!streq(name, "")) {
+ strcat(buffer, "/");
+ strcat(buffer, name);
+ }
+ return buffer;
+}
+
+char **xenbus_directory(const char *dir, const char *node, unsigned int *num)
{
char *strings, *p, **ret;
unsigned int len;
- strings = xs_single(XS_DIRECTORY, path, &len);
+ strings = xs_single(XS_DIRECTORY, join(dir, node), &len);
if (IS_ERR(strings))
return (char **)strings;
@@ -210,67 +226,37 @@
}
/* Check if a path exists. Return 1 if it does. */
-int xs_exists(const char *path)
-{
- char **dir;
+int xenbus_exists(const char *dir, const char *node)
+{
+ char **d;
int dir_n;
- dir = xs_directory(path, &dir_n);
- if (IS_ERR(dir))
+ d = xenbus_directory(path, node, &dir_n);
+ if (IS_ERR(d))
return 0;
- kfree(dir);
+ kfree(d);
return 1;
}
-
-/* Make a directory, creating dirs on the path to it if necessary.
- * Return 0 on success, error code otherwise.
- */
-int xs_mkdirs(const char *path)
-{
- int err = 0;
- char s[strlen(path) + 1], *p = s;
-
- if (xs_exists(path))
- goto out;
- strcpy(p, path);
- if (*p == '/')
- p++;
- for (;;) {
- p = strchr(p, '/');
- if (p)
- *p = '\0';
- if (!xs_exists(s)) {
- err = xs_mkdir(s);
- if (err)
- goto out;
- }
- if (!p)
- break;
- *p++ = '/';
- }
- out:
- return err;
-}
-
/* Get the value of a single file.
* Returns a kmalloced value: call free() on it after use.
* len indicates length in bytes.
*/
-void *xs_read(const char *path, unsigned int *len)
-{
- return xs_single(XS_READ, path, len);
+void *xenbus_read(const char *dir, const char *node, unsigned int *len)
+{
+ return xs_single(XS_READ, join(dir, node), len);
}
/* Write the value of a single file.
* Returns -err on failure. createflags can be 0, O_CREAT, or O_CREAT|O_EXCL.
*/
-int xs_write(const char *path,
- const void *data, unsigned int len, int createflags)
-{
- const char *flags;
+int xenbus_write(const char *dir, const char *node,
+ const char *string, int createflags)
+{
+ const char *flags, *path;
struct kvec iovec[3];
+ path = join(dir, node);
/* Format: Flags (as string), path, data. */
if (createflags == 0)
flags = XS_WRITE_NONE;
@@ -285,22 +271,22 @@
iovec[0].iov_len = strlen(path) + 1;
iovec[1].iov_base = (void *)flags;
iovec[1].iov_len = strlen(flags) + 1;
- iovec[2].iov_base = (void *)data;
- iovec[2].iov_len = len;
+ iovec[2].iov_base = (void *)string;
+ iovec[2].iov_len = strlen(string);
return xs_error(xs_talkv(XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL));
}
/* Create a new directory. */
-int xs_mkdir(const char *path)
-{
- return xs_error(xs_single(XS_MKDIR, path, NULL));
+int xenbus_mkdir(const char *dir, const char *node)
+{
+ return xs_error(xs_single(XS_MKDIR, join(dir, node), NULL));
}
/* Destroy a file or directory (directories must be empty). */
-int xs_rm(const char *path)
-{
- return xs_error(xs_single(XS_RM, path, NULL));
+int xenbus_rm(const char *dir, const char *node)
+{
+ return xs_error(xs_single(XS_RM, join(dir, node), NULL));
}
/* Start a transaction: changes by others will not be seen during this
@@ -308,7 +294,7 @@
* Transaction only applies to the given subtree.
* You can only have one transaction at any time.
*/
-int xs_transaction_start(const char *subtree)
+int xenbus_transaction_start(const char *subtree)
{
return xs_error(xs_single(XS_TRANSACTION_START, subtree, NULL));
}
@@ -316,7 +302,7 @@
/* End a transaction.
* If abandon is true, transaction is discarded instead of committed.
*/
-int xs_transaction_end(int abort)
+int xenbus_transaction_end(int abort)
{
char abortstr[2];
@@ -327,12 +313,68 @@
return xs_error(xs_single(XS_TRANSACTION_END, abortstr, NULL));
}
-char *xs_get_domain_path(domid_t domid)
-{
- char domid_str[32];
-
- sprintf(domid_str, "%u", domid);
- return xs_single(XS_GETDOMAINPATH, domid_str, NULL);
+/* Single read and scanf: returns -errno or num scanned. */
+int xenbus_scanf(const char *dir, const char *node, const char *fmt, ...)
+{
+ va_list ap;
+ int ret;
+ char *val;
+
+ val = xenbus_read(dir, node, NULL);
+ if (IS_ERR(val))
+ return PTR_ERR(val);
+
+ va_start(ap, fmt);
+ ret = vsscanf(val, fmt, ap);
+ va_end(ap);
+ kfree(val);
+ /* Distinctive errno. */
+ if (ret == 0)
+ return -ERANGE;
+ return ret;
+}
+
+/* Single printf and write: returns -errno or 0. */
+int xenbus_printf(const char *dir, const char *node, const char *fmt, ...)
+{
+ va_list ap;
+ int ret;
+ static char buffer[4096];
+
+ BUG_ON(down_trylock(&xenbus_lock) == 0);
+ va_start(ap, fmt);
+ ret = vsnprintf(buffer, sizeof(buffer), fmt, ap);
+ va_end(ap);
+
+ BUG_ON(ret > sizeof(buffer)-1);
+
+ return xenbus_write(dir, node, buffer, ret+1);
+}
+
+/* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
+int xenbus_gather(const char *dir, ...)
+{
+ va_list ap;
+ const char *name;
+ int ret = 0;
+
+ va_start(ap, dir);
+ while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
+ const char *fmt = va_arg(ap, char *);
+ void *result = va_arg(ap, void *);
+ char *p;
+
+ p = xenbus_read(dir, name, NULL);
+ if (IS_ERR(p)) {
+ ret = PTR_ERR(p);
+ break;
+ }
+ if (sscanf(p, fmt, result) == 0)
+ ret = -EINVAL;
+ kfree(p);
+ }
+ va_end(ap);
+ return ret;
}
static int xs_watch(const char *path, const char *token, unsigned int priority)
@@ -429,7 +471,6 @@
static int watch_thread(void *unused)
{
-
for (;;) {
char *token;
char *node = NULL;
@@ -440,7 +481,7 @@
* doing an op, they'll hold the lock and the buffer
* will be empty by the time we get there.
*/
- down(&xs_lock);
+ down(&xenbus_lock);
if (xs_input_avail(xs_in))
node = xs_read_watch(&token);
@@ -461,7 +502,7 @@
} else
printk(KERN_WARNING "XENBUS xs_read_watch: %li\n",
PTR_ERR(node));
- up(&xs_lock);
+ up(&xenbus_lock);
}
}
diff -r 62e13cae2f58 -r 2e6e1eb66c5e
linux-2.6-xen-sparse/include/asm-xen/xenbus.h
--- a/linux-2.6-xen-sparse/include/asm-xen/xenbus.h Tue Jul 26 15:57:18 2005
+++ b/linux-2.6-xen-sparse/include/asm-xen/xenbus.h Tue Jul 26 16:59:40 2005
@@ -36,7 +36,6 @@
char *devicetype;
char *subtype;
char *nodename;
- int id;
struct device dev;
void *data;
};
@@ -58,21 +57,11 @@
char *name;
struct module *owner;
const struct xenbus_device_id *ids;
- /* Called when xenstore is connected. */
- int (*connect) (struct xenbus_driver * drv);
-
- int (*probe) (struct xenbus_device * dev, const struct
xenbus_device_id * id);
+ int (*probe) (struct xenbus_device * dev,
+ const struct xenbus_device_id * id);
int (*remove) (struct xenbus_device * dev);
- int (*configure)(struct xenbus_device * dev);
struct device_driver driver;
-};
-
-struct xenbus_evtchn {
- unsigned long dom1;
- unsigned long port1;
- unsigned long dom2;
- unsigned long port2;
};
static inline struct xenbus_driver *to_xenbus_driver(struct device_driver *drv)
@@ -83,36 +72,31 @@
int xenbus_register_driver(struct xenbus_driver *drv);
void xenbus_unregister_driver(struct xenbus_driver *drv);
-int xenbus_register_backend(struct xenbus_driver *drv);
-void xenbus_unregister_backend(struct xenbus_driver *drv);
-
-/* Iterator over xenbus devices (frontend). */
-int xenbus_for_each_dev(struct xenbus_device * start, void * data,
- int (*fn)(struct xenbus_device *, void *));
-
-/* Iterator over xenbus drivers (frontend). */
-int xenbus_for_each_drv(struct xenbus_driver * start, void * data,
- int (*fn)(struct xenbus_driver *, void *));
-
-/* Iterator over xenbus drivers (backend). */
-int xenbus_for_each_backend(struct xenbus_driver * start, void * data,
- int (*fn)(struct xenbus_driver *, void *));
-
/* Caller must hold this lock to call these functions: it's also held
* across watch callbacks. */
-extern struct semaphore xs_lock;
+extern struct semaphore xenbus_lock;
-char **xs_directory(const char *path, unsigned int *num);
-void *xs_read(const char *path, unsigned int *len);
-int xs_write(const char *path,
- const void *data, unsigned int len, int createflags);
-int xs_mkdir(const char *path);
-int xs_exists(const char *path);
-int xs_mkdirs(const char *path);
-int xs_rm(const char *path);
-int xs_transaction_start(const char *subtree);
-int xs_transaction_end(int abort);
-char *xs_get_domain_path(domid_t domid);
+char **xenbus_directory(const char *dir, const char *node, unsigned int *num);
+void *xenbus_read(const char *dir, const char *node, unsigned int *len);
+int xenbus_write(const char *dir, const char *node,
+ const char *string, int createflags);
+int xenbus_mkdir(const char *dir, const char *node);
+int xenbus_exists(const char *dir, const char *node);
+int xenbus_rm(const char *dir, const char *node);
+int xenbus_transaction_start(const char *subtree);
+int xenbus_transaction_end(int abort);
+
+/* Single read and scanf: returns -errno or num scanned if > 0. */
+int xenbus_scanf(const char *dir, const char *node, const char *fmt, ...)
+ __attribute__((format(scanf, 3, 4)));
+
+/* Single printf and write: returns -errno or 0. */
+int xenbus_printf(const char *dir, const char *node, const char *fmt, ...)
+ __attribute__((format(printf, 3, 4)));
+
+/* Generic read function: NULL-terminated triples of name,
+ * sprintf-style type string, and pointer. Returns 0 or errno.*/
+int xenbus_gather(const char *dir, ...);
/* Register callback to watch this node. */
struct xenbus_watch
@@ -126,20 +110,4 @@
int register_xenbus_watch(struct xenbus_watch *watch);
void unregister_xenbus_watch(struct xenbus_watch *watch);
-/* Generic read function: NULL-terminated triples of name,
- * sprintf-style type string, and pointer. */
-int xenbus_gather(const char *dir, ...);
-
-char *xenbus_path(const char *dir, const char *name);
-char *xenbus_read(const char *dir, const char *name, unsigned int *data_n);
-int xenbus_write(const char *dir, const char *name,
- const char *data, int data_n);
-
-int xenbus_read_string(const char *dir, const char *name, char **val);
-int xenbus_write_string(const char *dir, const char *name, const char *val);
-int xenbus_read_ulong(const char *dir, const char *name, unsigned long *val);
-int xenbus_write_ulong(const char *dir, const char *name, unsigned long val);
-int xenbus_read_long(const char *dir, const char *name, long *val);
-int xenbus_write_long(const char *dir, const char *name, long val);
-
#endif /* _ASM_XEN_XENBUS_H */
_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |