kernel26-xen/patches-2.6.25-r1/1014-2.6.25-xen-Add-proc-xen-xenbus.patch

From 8b4585c4677d8e9e58a1e156b113494abd74c541 Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc@redhat.com>
Date: Mon, 4 Feb 2008 22:04:36 +0000
Subject: [PATCH] xen: Add /proc/xen/xenbus

This interface is used by userspace programs to talk to
xenstored.

Since xenstored makes itself available to Dom0 userspace
via a socket this should only really be useful in Domu,
but it turns out that Dom0 apps historically default
to using /proc/xen/xenbus rather than the socket.

Signed-off-by: Mark McLoughlin <markmc@redhat.com>
---
 drivers/xen/xenbus/xenbus_comms.h |    1 -
 drivers/xen/xenbus/xenbus_probe.c |    2 +
 drivers/xen/xenbus/xenbus_xs.c    |    1 +
 drivers/xen/xenctrl/Makefile      |    1 +
 drivers/xen/xenctrl/main.c        |    6 +
 drivers/xen/xenctrl/xenbus.c      |  398 +++++++++++++++++++++++++++++++++++++
 drivers/xen/xenctrl/xenctrl.h     |    6 +
 include/xen/xenbus.h              |    2 +
 8 files changed, 416 insertions(+), 1 deletions(-)
 create mode 100644 drivers/xen/xenctrl/xenbus.c

diff --git a/drivers/xen/xenbus/xenbus_comms.h b/drivers/xen/xenbus/xenbus_comms.h
index c21db75..fcc9b29 100644
--- a/drivers/xen/xenbus/xenbus_comms.h
+++ b/drivers/xen/xenbus/xenbus_comms.h
@@ -41,6 +41,5 @@ int xb_data_to_read(void);
 int xb_wait_for_data_to_read(void);
 int xs_input_avail(void);
 extern struct xenstore_domain_interface *xen_store_interface;
-extern int xen_store_evtchn;
 
 #endif /* _XENBUS_COMMS_H */
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 57ceb53..c811581 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -56,6 +56,8 @@
 #include "xenbus_probe.h"
 
 int xen_store_evtchn;
+EXPORT_SYMBOL_GPL(xen_store_evtchn);
+
 struct xenstore_domain_interface *xen_store_interface;
 static unsigned long xen_store_mfn;
 
diff --git a/drivers/xen/xenbus/xenbus_xs.c b/drivers/xen/xenbus/xenbus_xs.c
index 227d53b..810e24a 100644
--- a/drivers/xen/xenbus/xenbus_xs.c
+++ b/drivers/xen/xenbus/xenbus_xs.c
@@ -184,6 +184,7 @@ void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg)
 
 	return ret;
 }
+EXPORT_SYMBOL(xenbus_dev_request_and_reply);
 
 /* Send message to xs, get kmalloc'ed reply.  ERR_PTR() on error. */
 static void *xs_talkv(struct xenbus_transaction t,
diff --git a/drivers/xen/xenctrl/Makefile b/drivers/xen/xenctrl/Makefile
index 8a706cb..23dafa3 100644
--- a/drivers/xen/xenctrl/Makefile
+++ b/drivers/xen/xenctrl/Makefile
@@ -4,3 +4,4 @@ xenctrl-objs  =
 xenctrl-objs += main.o
 xenctrl-objs += capabilities.o
 xenctrl-objs += privcmd.o
+xenctrl-objs += xenbus.o
diff --git a/drivers/xen/xenctrl/main.c b/drivers/xen/xenctrl/main.c
index d1fe6ef..b0cf61b 100644
--- a/drivers/xen/xenctrl/main.c
+++ b/drivers/xen/xenctrl/main.c
@@ -59,8 +59,13 @@ static int __init xenctrl_init(void)
 	if (ret)
 		goto fail2;
 
+	ret = xenbus_create_proc_entry();
+	if (ret)
+		goto fail3;
+
 	return 0;
 
+ fail3: privcmd_remove_proc_entry();
  fail2: capabilities_remove_proc_entry();
  fail1:	remove_proc_entry("xen", NULL);
 	return ret;
@@ -68,6 +73,7 @@ static int __init xenctrl_init(void)
 
 static void __exit xenctrl_exit(void)
 {
+	xenbus_remove_proc_entry();
 	privcmd_remove_proc_entry();
 	capabilities_remove_proc_entry();
 	remove_proc_entry("xen", NULL);
diff --git a/drivers/xen/xenctrl/xenbus.c b/drivers/xen/xenctrl/xenbus.c
new file mode 100644
index 0000000..57d5501
--- /dev/null
+++ b/drivers/xen/xenctrl/xenbus.c
@@ -0,0 +1,398 @@
+/*
+ * xenbus.c
+ * 
+ * /proc/xen/xenbus gives user-space access to the kernel's xenbus
+ * connection to xenstore.
+ * 
+ * Copyright (c) 2005, Christian Limpach
+ * Copyright (c) 2005, Rusty Russell, IBM Corporation
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/proc_fs.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/poll.h>
+
+#include <xen/xenbus.h>
+
+struct xenbus_dev_transaction {
+	struct list_head list;
+	struct xenbus_transaction handle;
+};
+
+struct read_buffer {
+	struct list_head list;
+	unsigned int cons;
+	unsigned int len;
+	char msg[];
+};
+
+struct xenbus_dev_data {
+	/* In-progress transaction. */
+	struct list_head transactions;
+
+	/* Active watches. */
+	struct list_head watches;
+
+	/* Partial request. */
+	unsigned int len;
+	union {
+		struct xsd_sockmsg msg;
+		char buffer[PAGE_SIZE];
+	} u;
+
+	/* Response queue. */
+	struct list_head read_buffers;
+	wait_queue_head_t read_waitq;
+
+	struct mutex reply_mutex;
+};
+
+static ssize_t xenbus_dev_read(struct file *filp,
+			       char __user *ubuf,
+			       size_t len, loff_t *ppos)
+{
+	struct xenbus_dev_data *u = filp->private_data;
+	struct read_buffer *rb;
+	int i, ret;
+
+	mutex_lock(&u->reply_mutex);
+	while (list_empty(&u->read_buffers)) {
+		mutex_unlock(&u->reply_mutex);
+		ret = wait_event_interruptible(u->read_waitq,
+					       !list_empty(&u->read_buffers));
+		if (ret)
+			return ret;
+		mutex_lock(&u->reply_mutex);
+	}
+
+	rb = list_entry(u->read_buffers.next, struct read_buffer, list);
+	for (i = 0; i < len;) {
+		put_user(rb->msg[rb->cons], ubuf + i);
+		i++;
+		rb->cons++;
+		if (rb->cons == rb->len) {
+			list_del(&rb->list);
+			kfree(rb);
+			if (list_empty(&u->read_buffers))
+				break;
+			rb = list_entry(u->read_buffers.next,
+					struct read_buffer, list);
+		}
+	}
+	mutex_unlock(&u->reply_mutex);
+
+	return i;
+}
+
+static void queue_reply(struct xenbus_dev_data *u,
+			char *data, unsigned int len)
+{
+	struct read_buffer *rb;
+
+	if (len == 0)
+		return;
+
+	rb = kmalloc(sizeof(*rb) + len, GFP_KERNEL);
+	BUG_ON(rb == NULL);
+
+	rb->cons = 0;
+	rb->len = len;
+
+	memcpy(rb->msg, data, len);
+
+	list_add_tail(&rb->list, &u->read_buffers);
+
+	wake_up(&u->read_waitq);
+}
+
+struct watch_adapter
+{
+	struct list_head list;
+	struct xenbus_watch watch;
+	struct xenbus_dev_data *dev_data;
+	char *token;
+};
+
+static void free_watch_adapter(struct watch_adapter *watch)
+{
+	kfree(watch->watch.node);
+	kfree(watch->token);
+	kfree(watch);
+}
+
+static void watch_fired(struct xenbus_watch *watch,
+			const char **vec,
+			unsigned int len)
+{
+	struct watch_adapter *adap =
+            container_of(watch, struct watch_adapter, watch);
+	struct xsd_sockmsg hdr;
+	const char *path, *token;
+	int path_len, tok_len, body_len;
+
+	path = vec[XS_WATCH_PATH];
+	token = adap->token;
+
+	path_len = strlen(path) + 1;
+	tok_len = strlen(token) + 1;
+	body_len = path_len + tok_len;
+
+	hdr.type = XS_WATCH_EVENT;
+	hdr.len = body_len;
+
+	mutex_lock(&adap->dev_data->reply_mutex);
+	queue_reply(adap->dev_data, (char *)&hdr, sizeof(hdr));
+	queue_reply(adap->dev_data, (char *)path, path_len);
+	queue_reply(adap->dev_data, (char *)token, tok_len);
+	mutex_unlock(&adap->dev_data->reply_mutex);
+}
+
+static LIST_HEAD(watch_list);
+
+static ssize_t xenbus_dev_write(struct file *filp,
+				const char __user *ubuf,
+				size_t len, loff_t *ppos)
+{
+	struct xenbus_dev_data *u = filp->private_data;
+	struct xenbus_dev_transaction *trans = NULL;
+	uint32_t msg_type;
+	void *reply;
+	char *path, *token;
+	struct watch_adapter *watch, *tmp_watch;
+	int err, rc = len;
+
+	if ((len + u->len) > sizeof(u->u.buffer)) {
+		rc = -EINVAL;
+		goto out;
+	}
+
+	if (copy_from_user(u->u.buffer + u->len, ubuf, len) != 0) {
+		rc = -EFAULT;
+		goto out;
+	}
+
+	u->len += len;
+	if ((u->len < sizeof(u->u.msg)) ||
+	    (u->len < (sizeof(u->u.msg) + u->u.msg.len)))
+		return rc;
+
+	msg_type = u->u.msg.type;
+
+	switch (msg_type) {
+	case XS_TRANSACTION_START:
+	case XS_TRANSACTION_END:
+	case XS_DIRECTORY:
+	case XS_READ:
+	case XS_GET_PERMS:
+	case XS_RELEASE:
+	case XS_GET_DOMAIN_PATH:
+	case XS_WRITE:
+	case XS_MKDIR:
+	case XS_RM:
+	case XS_SET_PERMS:
+		if (msg_type == XS_TRANSACTION_START) {
+			trans = kmalloc(sizeof(*trans), GFP_KERNEL);
+			if (!trans) {
+				rc = -ENOMEM;
+				goto out;
+			}
+		}
+
+		reply = xenbus_dev_request_and_reply(&u->u.msg);
+		if (IS_ERR(reply)) {
+			kfree(trans);
+			rc = PTR_ERR(reply);
+			goto out;
+		}
+
+		if (msg_type == XS_TRANSACTION_START) {
+			trans->handle.id = simple_strtoul(reply, NULL, 0);
+			list_add(&trans->list, &u->transactions);
+		} else if (msg_type == XS_TRANSACTION_END) {
+			list_for_each_entry(trans, &u->transactions, list)
+				if (trans->handle.id == u->u.msg.tx_id)
+					break;
+			BUG_ON(&trans->list == &u->transactions);
+			list_del(&trans->list);
+			kfree(trans);
+		}
+		mutex_lock(&u->reply_mutex);
+		queue_reply(u, (char *)&u->u.msg, sizeof(u->u.msg));
+		queue_reply(u, (char *)reply, u->u.msg.len);
+		mutex_unlock(&u->reply_mutex);
+		kfree(reply);
+		break;
+
+	case XS_WATCH:
+	case XS_UNWATCH: {
+		static const char *XS_RESP = "OK";
+		struct xsd_sockmsg hdr;
+
+		path = u->u.buffer + sizeof(u->u.msg);
+		token = memchr(path, 0, u->u.msg.len);
+		if (token == NULL) {
+			rc = -EILSEQ;
+			goto out;
+		}
+		token++;
+
+		if (msg_type == XS_WATCH) {
+			watch = kmalloc(sizeof(*watch), GFP_KERNEL);
+			watch->watch.node = kmalloc(strlen(path)+1,
+                                                    GFP_KERNEL);
+			strcpy((char *)watch->watch.node, path);
+			watch->watch.callback = watch_fired;
+			watch->token = kmalloc(strlen(token)+1, GFP_KERNEL);
+			strcpy(watch->token, token);
+			watch->dev_data = u;
+
+			err = register_xenbus_watch(&watch->watch);
+			if (err) {
+				free_watch_adapter(watch);
+				rc = err;
+				goto out;
+			}
+			
+			list_add(&watch->list, &u->watches);
+		} else {
+			list_for_each_entry_safe(watch, tmp_watch,
+                                                 &u->watches, list) {
+				if (!strcmp(watch->token, token) &&
+				    !strcmp(watch->watch.node, path))
+				{
+					unregister_xenbus_watch(&watch->watch);
+					list_del(&watch->list);
+					free_watch_adapter(watch);
+					break;
+				}
+			}
+		}
+
+		hdr.type = msg_type;
+		hdr.len = strlen(XS_RESP) + 1;
+		mutex_lock(&u->reply_mutex);
+		queue_reply(u, (char *)&hdr, sizeof(hdr));
+		queue_reply(u, (char *)XS_RESP, hdr.len);
+		mutex_unlock(&u->reply_mutex);
+		break;
+	}
+
+	default:
+		rc = -EINVAL;
+		break;
+	}
+
+ out:
+	u->len = 0;
+	return rc;
+}
+
+static int xenbus_dev_open(struct inode *inode, struct file *filp)
+{
+	struct xenbus_dev_data *u;
+
+	if (xen_store_evtchn == 0)
+		return -ENOENT;
+
+	nonseekable_open(inode, filp);
+
+	u = kzalloc(sizeof(*u), GFP_KERNEL);
+	if (u == NULL)
+		return -ENOMEM;
+
+	INIT_LIST_HEAD(&u->transactions);
+	INIT_LIST_HEAD(&u->watches);
+	INIT_LIST_HEAD(&u->read_buffers);
+	init_waitqueue_head(&u->read_waitq);
+
+	mutex_init(&u->reply_mutex);
+
+	filp->private_data = u;
+
+	return 0;
+}
+
+static int xenbus_dev_release(struct inode *inode, struct file *filp)
+{
+	struct xenbus_dev_data *u = filp->private_data;
+	struct xenbus_dev_transaction *trans, *tmp;
+	struct watch_adapter *watch, *tmp_watch;
+
+	list_for_each_entry_safe(trans, tmp, &u->transactions, list) {
+		xenbus_transaction_end(trans->handle, 1);
+		list_del(&trans->list);
+		kfree(trans);
+	}
+
+	list_for_each_entry_safe(watch, tmp_watch, &u->watches, list) {
+		unregister_xenbus_watch(&watch->watch);
+		list_del(&watch->list);
+		free_watch_adapter(watch);
+	}
+
+	kfree(u);
+
+	return 0;
+}
+
+static unsigned int xenbus_dev_poll(struct file *file, poll_table *wait)
+{
+	struct xenbus_dev_data *u = file->private_data;
+
+	poll_wait(file, &u->read_waitq, wait);
+	if (!list_empty(&u->read_buffers))
+		return POLLIN | POLLRDNORM;
+	return 0;
+}
+
+static const struct file_operations xenbus_dev_file_ops = {
+	.read = xenbus_dev_read,
+	.write = xenbus_dev_write,
+	.open = xenbus_dev_open,
+	.release = xenbus_dev_release,
+	.poll = xenbus_dev_poll,
+};
+
+int __init xenbus_create_proc_entry(void)
+{
+	struct proc_dir_entry *entry;
+
+	entry = create_proc_entry("xen/xenbus", 0400, NULL);
+	if (!entry)
+		return -ENOMEM;
+
+	entry->owner = THIS_MODULE;
+	entry->proc_fops = &xenbus_dev_file_ops;
+
+	return 0;
+}
+
+void __exit xenbus_remove_proc_entry(void)
+{
+	remove_proc_entry("xen/xenbus", NULL);
+}
diff --git a/drivers/xen/xenctrl/xenctrl.h b/drivers/xen/xenctrl/xenctrl.h
index a35209a..e585c4b 100644
--- a/drivers/xen/xenctrl/xenctrl.h
+++ b/drivers/xen/xenctrl/xenctrl.h
@@ -43,3 +43,9 @@ void capabilities_remove_proc_entry(void) __exit;
  */
 int privcmd_create_proc_entry(void) __init;
 void privcmd_remove_proc_entry(void) __exit;
+
+/*
+ * xenbus.c
+ */
+int xenbus_create_proc_entry(void) __init;
+void xenbus_remove_proc_entry(void) __exit;
diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
index 6369d89..a3fef9d 100644
--- a/include/xen/xenbus.h
+++ b/include/xen/xenbus.h
@@ -232,4 +232,6 @@ const char *xenbus_strstate(enum xenbus_state state);
 int xenbus_dev_is_online(struct xenbus_device *dev);
 int xenbus_frontend_closed(struct xenbus_device *dev);
 
+extern int xen_store_evtchn;
+
 #endif /* _XEN_XENBUS_H */
-- 
1.5.4.1

1	From 8b4585c4677d8e9e58a1e156b113494abd74c541 Mon Sep 17 00:00:00 2001
2	From: Mark McLoughlin <markmc@redhat.com>
3	Date: Mon, 4 Feb 2008 22:04:36 +0000
4	Subject: [PATCH] xen: Add /proc/xen/xenbus
5
6	This interface is used by userspace programs to talk to
7	xenstored.
8
9	Since xenstored makes itself available to Dom0 userspace
10	via a socket this should only really be useful in Domu,
11	but it turns out that Dom0 apps historically default
12	to using /proc/xen/xenbus rather than the socket.
13
14	Signed-off-by: Mark McLoughlin <markmc@redhat.com>
15	---
16	drivers/xen/xenbus/xenbus_comms.h \| 1 -
17	drivers/xen/xenbus/xenbus_probe.c \| 2 +
18	drivers/xen/xenbus/xenbus_xs.c \| 1 +
19	drivers/xen/xenctrl/Makefile \| 1 +
20	drivers/xen/xenctrl/main.c \| 6 +
21	drivers/xen/xenctrl/xenbus.c \| 398 +++++++++++++++++++++++++++++++++++++
22	drivers/xen/xenctrl/xenctrl.h \| 6 +
23	include/xen/xenbus.h \| 2 +
24	8 files changed, 416 insertions(+), 1 deletions(-)
25	create mode 100644 drivers/xen/xenctrl/xenbus.c
26
27	diff --git a/drivers/xen/xenbus/xenbus_comms.h b/drivers/xen/xenbus/xenbus_comms.h
28	index c21db75..fcc9b29 100644
29	--- a/drivers/xen/xenbus/xenbus_comms.h
30	+++ b/drivers/xen/xenbus/xenbus_comms.h
31	@@ -41,6 +41,5 @@ int xb_data_to_read(void);
32	int xb_wait_for_data_to_read(void);
33	int xs_input_avail(void);
34	extern struct xenstore_domain_interface *xen_store_interface;
35	-extern int xen_store_evtchn;
36
37	#endif /* _XENBUS_COMMS_H */
38	diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
39	index 57ceb53..c811581 100644
40	--- a/drivers/xen/xenbus/xenbus_probe.c
41	+++ b/drivers/xen/xenbus/xenbus_probe.c
42	@@ -56,6 +56,8 @@
43	#include "xenbus_probe.h"
44
45	int xen_store_evtchn;
46	+EXPORT_SYMBOL_GPL(xen_store_evtchn);
47	+
48	struct xenstore_domain_interface *xen_store_interface;
49	static unsigned long xen_store_mfn;
50
51	diff --git a/drivers/xen/xenbus/xenbus_xs.c b/drivers/xen/xenbus/xenbus_xs.c
52	index 227d53b..810e24a 100644
53	--- a/drivers/xen/xenbus/xenbus_xs.c
54	+++ b/drivers/xen/xenbus/xenbus_xs.c
55	@@ -184,6 +184,7 @@ void xenbus_dev_request_and_reply(struct xsd_sockmsg msg)
56
57	return ret;
58	}
59	+EXPORT_SYMBOL(xenbus_dev_request_and_reply);
60
61	/* Send message to xs, get kmalloc'ed reply. ERR_PTR() on error. */
62	static void *xs_talkv(struct xenbus_transaction t,
63	diff --git a/drivers/xen/xenctrl/Makefile b/drivers/xen/xenctrl/Makefile
64	index 8a706cb..23dafa3 100644
65	--- a/drivers/xen/xenctrl/Makefile
66	+++ b/drivers/xen/xenctrl/Makefile
67	@@ -4,3 +4,4 @@ xenctrl-objs =
68	xenctrl-objs += main.o
69	xenctrl-objs += capabilities.o
70	xenctrl-objs += privcmd.o
71	+xenctrl-objs += xenbus.o
72	diff --git a/drivers/xen/xenctrl/main.c b/drivers/xen/xenctrl/main.c
73	index d1fe6ef..b0cf61b 100644
74	--- a/drivers/xen/xenctrl/main.c
75	+++ b/drivers/xen/xenctrl/main.c
76	@@ -59,8 +59,13 @@ static int __init xenctrl_init(void)
77	if (ret)
78	goto fail2;
79
80	+ ret = xenbus_create_proc_entry();
81	+ if (ret)
82	+ goto fail3;
83	+
84	return 0;
85
86	+ fail3: privcmd_remove_proc_entry();
87	fail2: capabilities_remove_proc_entry();
88	fail1: remove_proc_entry("xen", NULL);
89	return ret;
90	@@ -68,6 +73,7 @@ static int __init xenctrl_init(void)
91
92	static void __exit xenctrl_exit(void)
93	{
94	+ xenbus_remove_proc_entry();
95	privcmd_remove_proc_entry();
96	capabilities_remove_proc_entry();
97	remove_proc_entry("xen", NULL);
98	diff --git a/drivers/xen/xenctrl/xenbus.c b/drivers/xen/xenctrl/xenbus.c
99	new file mode 100644
100	index 0000000..57d5501
101	--- /dev/null
102	+++ b/drivers/xen/xenctrl/xenbus.c
103	@@ -0,0 +1,398 @@
104	+/*
105	+ * xenbus.c
106	+ *
107	+ * /proc/xen/xenbus gives user-space access to the kernel's xenbus
108	+ * connection to xenstore.
109	+ *
110	+ * Copyright (c) 2005, Christian Limpach
111	+ * Copyright (c) 2005, Rusty Russell, IBM Corporation
112	+ *
113	+ * This program is free software; you can redistribute it and/or
114	+ * modify it under the terms of the GNU General Public License version 2
115	+ * as published by the Free Software Foundation; or, when distributed
116	+ * separately from the Linux kernel or incorporated into other
117	+ * software packages, subject to the following license:
118	+ *
119	+ * Permission is hereby granted, free of charge, to any person obtaining a copy
120	+ * of this source file (the "Software"), to deal in the Software without
121	+ * restriction, including without limitation the rights to use, copy, modify,
122	+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
123	+ * and to permit persons to whom the Software is furnished to do so, subject to
124	+ * the following conditions:
125	+ *
126	+ * The above copyright notice and this permission notice shall be included in
127	+ * all copies or substantial portions of the Software.
128	+ *
129	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
130	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
131	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
132	+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
133	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
134	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
135	+ * IN THE SOFTWARE.
136	+ */
137	+
138	+#include <linux/proc_fs.h>
139	+#include <linux/module.h>
140	+#include <linux/uaccess.h>
141	+#include <linux/poll.h>
142	+
143	+#include <xen/xenbus.h>
144	+
145	+struct xenbus_dev_transaction {
146	+ struct list_head list;
147	+ struct xenbus_transaction handle;
148	+};
149	+
150	+struct read_buffer {
151	+ struct list_head list;
152	+ unsigned int cons;
153	+ unsigned int len;
154	+ char msg[];
155	+};
156	+
157	+struct xenbus_dev_data {
158	+ /* In-progress transaction. */
159	+ struct list_head transactions;
160	+
161	+ /* Active watches. */
162	+ struct list_head watches;
163	+
164	+ /* Partial request. */
165	+ unsigned int len;
166	+ union {
167	+ struct xsd_sockmsg msg;
168	+ char buffer[PAGE_SIZE];
169	+ } u;
170	+
171	+ /* Response queue. */
172	+ struct list_head read_buffers;
173	+ wait_queue_head_t read_waitq;
174	+
175	+ struct mutex reply_mutex;
176	+};
177	+
178	+static ssize_t xenbus_dev_read(struct file *filp,
179	+ char __user *ubuf,
180	+ size_t len, loff_t *ppos)
181	+{
182	+ struct xenbus_dev_data *u = filp->private_data;
183	+ struct read_buffer *rb;
184	+ int i, ret;
185	+
186	+ mutex_lock(&u->reply_mutex);
187	+ while (list_empty(&u->read_buffers)) {
188	+ mutex_unlock(&u->reply_mutex);
189	+ ret = wait_event_interruptible(u->read_waitq,
190	+ !list_empty(&u->read_buffers));
191	+ if (ret)
192	+ return ret;
193	+ mutex_lock(&u->reply_mutex);
194	+ }
195	+
196	+ rb = list_entry(u->read_buffers.next, struct read_buffer, list);
197	+ for (i = 0; i < len;) {
198	+ put_user(rb->msg[rb->cons], ubuf + i);
199	+ i++;
200	+ rb->cons++;
201	+ if (rb->cons == rb->len) {
202	+ list_del(&rb->list);
203	+ kfree(rb);
204	+ if (list_empty(&u->read_buffers))
205	+ break;
206	+ rb = list_entry(u->read_buffers.next,
207	+ struct read_buffer, list);
208	+ }
209	+ }
210	+ mutex_unlock(&u->reply_mutex);
211	+
212	+ return i;
213	+}
214	+
215	+static void queue_reply(struct xenbus_dev_data *u,
216	+ char *data, unsigned int len)
217	+{
218	+ struct read_buffer *rb;
219	+
220	+ if (len == 0)
221	+ return;
222	+
223	+ rb = kmalloc(sizeof(*rb) + len, GFP_KERNEL);
224	+ BUG_ON(rb == NULL);
225	+
226	+ rb->cons = 0;
227	+ rb->len = len;
228	+
229	+ memcpy(rb->msg, data, len);
230	+
231	+ list_add_tail(&rb->list, &u->read_buffers);
232	+
233	+ wake_up(&u->read_waitq);
234	+}
235	+
236	+struct watch_adapter
237	+{
238	+ struct list_head list;
239	+ struct xenbus_watch watch;
240	+ struct xenbus_dev_data *dev_data;
241	+ char *token;
242	+};
243	+
244	+static void free_watch_adapter(struct watch_adapter *watch)
245	+{
246	+ kfree(watch->watch.node);
247	+ kfree(watch->token);
248	+ kfree(watch);
249	+}
250	+
251	+static void watch_fired(struct xenbus_watch *watch,
252	+ const char **vec,
253	+ unsigned int len)
254	+{
255	+ struct watch_adapter *adap =
256	+ container_of(watch, struct watch_adapter, watch);
257	+ struct xsd_sockmsg hdr;
258	+ const char path, token;
259	+ int path_len, tok_len, body_len;
260	+
261	+ path = vec[XS_WATCH_PATH];
262	+ token = adap->token;
263	+
264	+ path_len = strlen(path) + 1;
265	+ tok_len = strlen(token) + 1;
266	+ body_len = path_len + tok_len;
267	+
268	+ hdr.type = XS_WATCH_EVENT;
269	+ hdr.len = body_len;
270	+
271	+ mutex_lock(&adap->dev_data->reply_mutex);
272	+ queue_reply(adap->dev_data, (char *)&hdr, sizeof(hdr));
273	+ queue_reply(adap->dev_data, (char *)path, path_len);
274	+ queue_reply(adap->dev_data, (char *)token, tok_len);
275	+ mutex_unlock(&adap->dev_data->reply_mutex);
276	+}
277	+
278	+static LIST_HEAD(watch_list);
279	+
280	+static ssize_t xenbus_dev_write(struct file *filp,
281	+ const char __user *ubuf,
282	+ size_t len, loff_t *ppos)
283	+{
284	+ struct xenbus_dev_data *u = filp->private_data;
285	+ struct xenbus_dev_transaction *trans = NULL;
286	+ uint32_t msg_type;
287	+ void *reply;
288	+ char path, token;
289	+ struct watch_adapter watch, tmp_watch;
290	+ int err, rc = len;
291	+
292	+ if ((len + u->len) > sizeof(u->u.buffer)) {
293	+ rc = -EINVAL;
294	+ goto out;
295	+ }
296	+
297	+ if (copy_from_user(u->u.buffer + u->len, ubuf, len) != 0) {
298	+ rc = -EFAULT;
299	+ goto out;
300	+ }
301	+
302	+ u->len += len;
303	+ if ((u->len < sizeof(u->u.msg)) \|\|
304	+ (u->len < (sizeof(u->u.msg) + u->u.msg.len)))
305	+ return rc;
306	+
307	+ msg_type = u->u.msg.type;
308	+
309	+ switch (msg_type) {
310	+ case XS_TRANSACTION_START:
311	+ case XS_TRANSACTION_END:
312	+ case XS_DIRECTORY:
313	+ case XS_READ:
314	+ case XS_GET_PERMS:
315	+ case XS_RELEASE:
316	+ case XS_GET_DOMAIN_PATH:
317	+ case XS_WRITE:
318	+ case XS_MKDIR:
319	+ case XS_RM:
320	+ case XS_SET_PERMS:
321	+ if (msg_type == XS_TRANSACTION_START) {
322	+ trans = kmalloc(sizeof(*trans), GFP_KERNEL);
323	+ if (!trans) {
324	+ rc = -ENOMEM;
325	+ goto out;
326	+ }
327	+ }
328	+
329	+ reply = xenbus_dev_request_and_reply(&u->u.msg);
330	+ if (IS_ERR(reply)) {
331	+ kfree(trans);
332	+ rc = PTR_ERR(reply);
333	+ goto out;
334	+ }
335	+
336	+ if (msg_type == XS_TRANSACTION_START) {
337	+ trans->handle.id = simple_strtoul(reply, NULL, 0);
338	+ list_add(&trans->list, &u->transactions);
339	+ } else if (msg_type == XS_TRANSACTION_END) {
340	+ list_for_each_entry(trans, &u->transactions, list)
341	+ if (trans->handle.id == u->u.msg.tx_id)
342	+ break;
343	+ BUG_ON(&trans->list == &u->transactions);
344	+ list_del(&trans->list);
345	+ kfree(trans);
346	+ }
347	+ mutex_lock(&u->reply_mutex);
348	+ queue_reply(u, (char *)&u->u.msg, sizeof(u->u.msg));
349	+ queue_reply(u, (char *)reply, u->u.msg.len);
350	+ mutex_unlock(&u->reply_mutex);
351	+ kfree(reply);
352	+ break;
353	+
354	+ case XS_WATCH:
355	+ case XS_UNWATCH: {
356	+ static const char *XS_RESP = "OK";
357	+ struct xsd_sockmsg hdr;
358	+
359	+ path = u->u.buffer + sizeof(u->u.msg);
360	+ token = memchr(path, 0, u->u.msg.len);
361	+ if (token == NULL) {
362	+ rc = -EILSEQ;
363	+ goto out;
364	+ }
365	+ token++;
366	+
367	+ if (msg_type == XS_WATCH) {
368	+ watch = kmalloc(sizeof(*watch), GFP_KERNEL);
369	+ watch->watch.node = kmalloc(strlen(path)+1,
370	+ GFP_KERNEL);
371	+ strcpy((char *)watch->watch.node, path);
372	+ watch->watch.callback = watch_fired;
373	+ watch->token = kmalloc(strlen(token)+1, GFP_KERNEL);
374	+ strcpy(watch->token, token);
375	+ watch->dev_data = u;
376	+
377	+ err = register_xenbus_watch(&watch->watch);
378	+ if (err) {
379	+ free_watch_adapter(watch);
380	+ rc = err;
381	+ goto out;
382	+ }
383	+
384	+ list_add(&watch->list, &u->watches);
385	+ } else {
386	+ list_for_each_entry_safe(watch, tmp_watch,
387	+ &u->watches, list) {
388	+ if (!strcmp(watch->token, token) &&
389	+ !strcmp(watch->watch.node, path))
390	+ {
391	+ unregister_xenbus_watch(&watch->watch);
392	+ list_del(&watch->list);
393	+ free_watch_adapter(watch);
394	+ break;
395	+ }
396	+ }
397	+ }
398	+
399	+ hdr.type = msg_type;
400	+ hdr.len = strlen(XS_RESP) + 1;
401	+ mutex_lock(&u->reply_mutex);
402	+ queue_reply(u, (char *)&hdr, sizeof(hdr));
403	+ queue_reply(u, (char *)XS_RESP, hdr.len);
404	+ mutex_unlock(&u->reply_mutex);
405	+ break;
406	+ }
407	+
408	+ default:
409	+ rc = -EINVAL;
410	+ break;
411	+ }
412	+
413	+ out:
414	+ u->len = 0;
415	+ return rc;
416	+}
417	+
418	+static int xenbus_dev_open(struct inode inode, struct file filp)
419	+{
420	+ struct xenbus_dev_data *u;
421	+
422	+ if (xen_store_evtchn == 0)
423	+ return -ENOENT;
424	+
425	+ nonseekable_open(inode, filp);
426	+
427	+ u = kzalloc(sizeof(*u), GFP_KERNEL);
428	+ if (u == NULL)
429	+ return -ENOMEM;
430	+
431	+ INIT_LIST_HEAD(&u->transactions);
432	+ INIT_LIST_HEAD(&u->watches);
433	+ INIT_LIST_HEAD(&u->read_buffers);
434	+ init_waitqueue_head(&u->read_waitq);
435	+
436	+ mutex_init(&u->reply_mutex);
437	+
438	+ filp->private_data = u;
439	+
440	+ return 0;
441	+}
442	+
443	+static int xenbus_dev_release(struct inode inode, struct file filp)
444	+{
445	+ struct xenbus_dev_data *u = filp->private_data;
446	+ struct xenbus_dev_transaction trans, tmp;
447	+ struct watch_adapter watch, tmp_watch;
448	+
449	+ list_for_each_entry_safe(trans, tmp, &u->transactions, list) {
450	+ xenbus_transaction_end(trans->handle, 1);
451	+ list_del(&trans->list);
452	+ kfree(trans);
453	+ }
454	+
455	+ list_for_each_entry_safe(watch, tmp_watch, &u->watches, list) {
456	+ unregister_xenbus_watch(&watch->watch);
457	+ list_del(&watch->list);
458	+ free_watch_adapter(watch);
459	+ }
460	+
461	+ kfree(u);
462	+
463	+ return 0;
464	+}
465	+
466	+static unsigned int xenbus_dev_poll(struct file file, poll_table wait)
467	+{
468	+ struct xenbus_dev_data *u = file->private_data;
469	+
470	+ poll_wait(file, &u->read_waitq, wait);
471	+ if (!list_empty(&u->read_buffers))
472	+ return POLLIN \| POLLRDNORM;
473	+ return 0;
474	+}
475	+
476	+static const struct file_operations xenbus_dev_file_ops = {
477	+ .read = xenbus_dev_read,
478	+ .write = xenbus_dev_write,
479	+ .open = xenbus_dev_open,
480	+ .release = xenbus_dev_release,
481	+ .poll = xenbus_dev_poll,
482	+};
483	+
484	+int __init xenbus_create_proc_entry(void)
485	+{
486	+ struct proc_dir_entry *entry;
487	+
488	+ entry = create_proc_entry("xen/xenbus", 0400, NULL);
489	+ if (!entry)
490	+ return -ENOMEM;
491	+
492	+ entry->owner = THIS_MODULE;
493	+ entry->proc_fops = &xenbus_dev_file_ops;
494	+
495	+ return 0;
496	+}
497	+
498	+void __exit xenbus_remove_proc_entry(void)
499	+{
500	+ remove_proc_entry("xen/xenbus", NULL);
501	+}
502	diff --git a/drivers/xen/xenctrl/xenctrl.h b/drivers/xen/xenctrl/xenctrl.h
503	index a35209a..e585c4b 100644
504	--- a/drivers/xen/xenctrl/xenctrl.h
505	+++ b/drivers/xen/xenctrl/xenctrl.h
506	@@ -43,3 +43,9 @@ void capabilities_remove_proc_entry(void) __exit;
507	*/
508	int privcmd_create_proc_entry(void) __init;
509	void privcmd_remove_proc_entry(void) __exit;
510	+
511	+/*
512	+ * xenbus.c
513	+ */
514	+int xenbus_create_proc_entry(void) __init;
515	+void xenbus_remove_proc_entry(void) __exit;
516	diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
517	index 6369d89..a3fef9d 100644
518	--- a/include/xen/xenbus.h
519	+++ b/include/xen/xenbus.h
520	@@ -232,4 +232,6 @@ const char *xenbus_strstate(enum xenbus_state state);
521	int xenbus_dev_is_online(struct xenbus_device *dev);
522	int xenbus_frontend_closed(struct xenbus_device *dev);
523
524	+extern int xen_store_evtchn;
525	+
526	#endif /* _XEN_XENBUS_H */
527	--
528	1.5.4.1
529