35 #include <linux/errno.h>
36 #include <linux/types.h>
37 #include <linux/uio.h>
38 #include <linux/kernel.h>
39 #include <linux/string.h>
41 #include <linux/slab.h>
42 #include <linux/fcntl.h>
45 #include <linux/module.h>
47 #include <asm/xen/hypervisor.h>
51 #include <asm/xen/hypervisor.h>
123 static pid_t xenwatch_pid;
127 static int get_error(
const char *errorstring)
134 "XENBUS xen store gave: unknown error %s",
147 spin_lock(&xs_state.reply_lock);
149 while (list_empty(&xs_state.reply_list)) {
150 spin_unlock(&xs_state.reply_lock);
153 !list_empty(&xs_state.reply_list));
154 spin_lock(&xs_state.reply_lock);
161 spin_unlock(&xs_state.reply_lock);
163 *type = msg->
hdr.type;
173 static void transaction_start(
void)
180 static void transaction_end(
void)
183 wake_up(&xs_state.transaction_wq);
186 static void transaction_suspend(
void)
193 static void transaction_resume(
void)
214 ret = read_reply(&msg->
type, &msg->
len);
231 unsigned int num_vecs,
243 for (i = 0; i < num_vecs; i++)
254 for (i = 0; i < num_vecs; i++) {
255 err =
xb_write(iovec[i].iov_base, iovec[i].iov_len);
262 ret = read_reply(&msg.type, len);
270 err = get_error(ret);
272 return ERR_PTR(-err);
275 if (msg.type != type) {
276 if (printk_ratelimit())
278 "XENBUS unexpected type [%d], expected [%d]\n",
296 return xs_talkv(t, type, &iovec, 1, len);
300 static int xs_error(
char *reply)
303 return PTR_ERR(reply);
308 static unsigned int count_strings(
const char *strings,
unsigned int len)
313 for (p = strings, num = 0; p < strings + len; p +=
strlen(p) + 1)
320 static char *join(
const char *dir,
const char *
name)
328 return (!buffer) ? ERR_PTR(-
ENOMEM) : buffer;
331 static char **
split(
char *strings,
unsigned int len,
unsigned int *num)
336 *num = count_strings(strings, len);
344 memcpy(&ret[*num], strings, len);
347 strings = (
char *)&ret[*num];
348 for (p = strings, *num = 0; p < strings + len; p +=
strlen(p) + 1)
355 const char *dir,
const char *
node,
unsigned int *num)
357 char *strings, *
path;
360 path = join(dir, node);
362 return (
char **)
path;
367 return (
char **)strings;
369 return split(strings, len, num);
375 const char *dir,
const char *
node)
393 const char *dir,
const char *
node,
unsigned int *len)
398 path = join(dir, node);
402 ret = xs_single(t,
XS_READ, path, len);
412 const char *dir,
const char *
node,
const char *
string)
415 struct kvec iovec[2];
418 path = join(dir, node);
420 return PTR_ERR(path);
435 const char *dir,
const char *
node)
440 path = join(dir, node);
442 return PTR_ERR(path);
456 path = join(dir, node);
458 return PTR_ERR(path);
460 ret = xs_error(xs_single(t,
XS_RM, path,
NULL));
476 if (IS_ERR(id_str)) {
478 return PTR_ERR(id_str);
510 const char *dir,
const char *
node,
const char *
fmt, ...)
533 const char *dir,
const char *
node,
const char *
fmt, ...)
562 while (ret == 0 && (name =
va_arg(ap,
char *)) !=
NULL) {
573 if (
sscanf(p, fmt, result) == 0)
577 *(
char **)result = p;
584 static int xs_watch(
const char *
path,
const char *
token)
589 iov[0].iov_len =
strlen(path) + 1;
590 iov[1].iov_base = (
void *)token;
591 iov[1].iov_len =
strlen(token) + 1;
597 static int xs_unwatch(
const char *path,
const char *token)
602 iov[0].iov_len =
strlen(path) + 1;
603 iov[1].iov_base = (
char *)token;
604 iov[1].iov_len =
strlen(token) + 1;
610 static struct xenbus_watch *find_watch(
const char *token)
628 static
bool xen_strict_xenbus_quirk(
void)
633 base = xen_cpuid_base();
634 cpuid(base + 1, &eax, &ebx, &ecx, &edx);
642 static void xs_reset_watches(
void)
644 int err, supported = 0;
649 if (xen_strict_xenbus_quirk())
653 "platform-feature-xs_reset_watches",
"%d", &supported);
654 if (err != 1 || !supported)
658 if (err && err != -
EEXIST)
666 char token[
sizeof(
watch) * 2 + 1];
669 sprintf(token,
"%lX", (
long)watch);
673 spin_lock(&watches_lock);
674 BUG_ON(find_watch(token));
675 list_add(&watch->list, &watches);
676 spin_unlock(&watches_lock);
678 err = xs_watch(watch->node, token);
681 spin_lock(&watches_lock);
683 spin_unlock(&watches_lock);
686 up_read(&xs_state.watch_mutex);
695 char token[
sizeof(
watch) * 2 + 1];
698 sprintf(token,
"%lX", (
long)watch);
702 spin_lock(&watches_lock);
703 BUG_ON(!find_watch(token));
705 spin_unlock(&watches_lock);
707 err = xs_unwatch(watch->node, token);
710 "XENBUS Failed to release watch %s: %i\n",
713 up_read(&xs_state.watch_mutex);
717 if (
current->pid != xenwatch_pid)
721 spin_lock(&watch_events_lock);
723 if (msg->
u.
watch.handle != watch)
729 spin_unlock(&watch_events_lock);
731 if (
current->pid != xenwatch_pid)
738 transaction_suspend();
747 char token[
sizeof(
watch) * 2 + 1];
753 transaction_resume();
757 sprintf(token,
"%lX", (
long)watch);
758 xs_watch(watch->node, token);
772 static int xenwatch_thread(
void *
unused)
779 !list_empty(&watch_events));
786 spin_lock(&watch_events_lock);
787 ent = watch_events.
next;
788 if (ent != &watch_events)
790 spin_unlock(&watch_events_lock);
792 if (ent != &watch_events) {
794 msg->
u.
watch.handle->callback(
796 (
const char **)msg->
u.
watch.vec,
808 static int process_msg(
void)
861 body[msg->
hdr.len] =
'\0';
866 if (IS_ERR(msg->
u.
watch.vec)) {
867 err = PTR_ERR(msg->
u.
watch.vec);
872 spin_lock(&watches_lock);
873 msg->
u.
watch.handle = find_watch(
875 if (msg->
u.
watch.handle != NULL) {
876 spin_lock(&watch_events_lock);
879 spin_unlock(&watch_events_lock);
884 spin_unlock(&watches_lock);
887 spin_lock(&xs_state.reply_lock);
889 spin_unlock(&xs_state.reply_lock);
890 wake_up(&xs_state.reply_waitq);
898 static int xenbus_thread(
void *unused)
919 INIT_LIST_HEAD(&xs_state.reply_list);
935 task =
kthread_run(xenwatch_thread, NULL,
"xenwatch");
937 return PTR_ERR(task);
938 xenwatch_pid = task->
pid;
942 return PTR_ERR(task);