xenbus_xs.c

  1/******************************************************************************
  2 * xenbus_xs.c
  3 *
  4 * This is the kernel equivalent of the "xs" library.  We don't need everything
  5 * and we use xenbus_comms for communication.
  6 *
  7 * Copyright (C) 2005 Rusty Russell, IBM Corporation
  8 *
  9 * This program is free software; you can redistribute it and/or
 10 * modify it under the terms of the GNU General Public License version 2
 11 * as published by the Free Software Foundation; or, when distributed
 12 * separately from the Linux kernel or incorporated into other
 13 * software packages, subject to the following license:
 14 *
 15 * Permission is hereby granted, free of charge, to any person obtaining a copy
 16 * of this source file (the "Software"), to deal in the Software without
 17 * restriction, including without limitation the rights to use, copy, modify,
 18 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
 19 * and to permit persons to whom the Software is furnished to do so, subject to
 20 * the following conditions:
 21 *
 22 * The above copyright notice and this permission notice shall be included in
 23 * all copies or substantial portions of the Software.
 24 *
 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 26 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 28 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 29 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 30 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 31 * IN THE SOFTWARE.
 32 */
 33
 34#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 35
 36#include <linux/unistd.h>
 37#include <linux/errno.h>
 38#include <linux/types.h>
 39#include <linux/uio.h>
 40#include <linux/kernel.h>
 41#include <linux/string.h>
 42#include <linux/err.h>
 43#include <linux/slab.h>
 44#include <linux/fcntl.h>
 45#include <linux/kthread.h>
 46#include <linux/reboot.h>
 47#include <linux/rwsem.h>
 48#include <linux/mutex.h>
 49#include <asm/xen/hypervisor.h>
 50#include <xen/xenbus.h>
 51#include <xen/xen.h>
 52#include "xenbus.h"
 53
 54/*
 55 * Framework to protect suspend/resume handling against normal Xenstore
 56 * message handling:
 57 * During suspend/resume there must be no open transaction and no pending
 58 * Xenstore request.
 59 * New watch events happening in this time can be ignored by firing all watches
 60 * after resume.
 61 */
 62
 63/* Lock protecting enter/exit critical region. */
 64static DEFINE_SPINLOCK(xs_state_lock);
 65/* Number of users in critical region (protected by xs_state_lock). */
 66static unsigned int xs_state_users;
 67/* Suspend handler waiting or already active (protected by xs_state_lock)? */
 68static int xs_suspend_active;
 69/* Unique Xenstore request id (protected by xs_state_lock). */
 70static uint32_t xs_request_id;
 71
 72/* Wait queue for all callers waiting for critical region to become usable. */
 73static DECLARE_WAIT_QUEUE_HEAD(xs_state_enter_wq);
 74/* Wait queue for suspend handling waiting for critical region being empty. */
 75static DECLARE_WAIT_QUEUE_HEAD(xs_state_exit_wq);
 76
 77/* List of registered watches, and a lock to protect it. */
 78static LIST_HEAD(watches);
 79static DEFINE_SPINLOCK(watches_lock);
 80
 81/* List of pending watch callback events, and a lock to protect it. */
 82static LIST_HEAD(watch_events);
 83static DEFINE_SPINLOCK(watch_events_lock);
 84
 85/* Protect watch (de)register against save/restore. */
 86static DECLARE_RWSEM(xs_watch_rwsem);
 87
 88/*
 89 * Details of the xenwatch callback kernel thread. The thread waits on the
 90 * watch_events_waitq for work to do (queued on watch_events list). When it
 91 * wakes up it acquires the xenwatch_mutex before reading the list and
 92 * carrying out work.
 93 */
 94static pid_t xenwatch_pid;
 95static DEFINE_MUTEX(xenwatch_mutex);
 96static DECLARE_WAIT_QUEUE_HEAD(watch_events_waitq);
 97
 98static void xs_suspend_enter(void)
 99{
100	spin_lock(&xs_state_lock);
101	xs_suspend_active++;
102	spin_unlock(&xs_state_lock);
103	wait_event(xs_state_exit_wq, xs_state_users == 0);
104}
105
106static void xs_suspend_exit(void)
107{
108	xb_dev_generation_id++;
109	spin_lock(&xs_state_lock);
110	xs_suspend_active--;
111	spin_unlock(&xs_state_lock);
112	wake_up_all(&xs_state_enter_wq);
113}
114
115void xs_free_req(struct kref *kref)
116{
117	struct xb_req_data *req = container_of(kref, struct xb_req_data, kref);
118	kfree(req);
119}
120
121static uint32_t xs_request_enter(struct xb_req_data *req)
122{
123	uint32_t rq_id;
124
125	req->type = req->msg.type;
126
127	spin_lock(&xs_state_lock);
128
129	while (!xs_state_users && xs_suspend_active) {
130		spin_unlock(&xs_state_lock);
131		wait_event(xs_state_enter_wq, xs_suspend_active == 0);
132		spin_lock(&xs_state_lock);
133	}
134
135	if (req->type == XS_TRANSACTION_START && !req->user_req)
136		xs_state_users++;
137	xs_state_users++;
138	rq_id = xs_request_id++;
139
140	spin_unlock(&xs_state_lock);
141
142	return rq_id;
143}
144
145void xs_request_exit(struct xb_req_data *req)
146{
147	spin_lock(&xs_state_lock);
148	xs_state_users--;
149	if ((req->type == XS_TRANSACTION_START && req->msg.type == XS_ERROR) ||
150	    (req->type == XS_TRANSACTION_END && !req->user_req &&
151	     !WARN_ON_ONCE(req->msg.type == XS_ERROR &&
152			   !strcmp(req->body, "ENOENT"))))
153		xs_state_users--;
154	spin_unlock(&xs_state_lock);
155
156	if (xs_suspend_active && !xs_state_users)
157		wake_up(&xs_state_exit_wq);
158}
159
160static int get_error(const char *errorstring)
161{
162	unsigned int i;
163
164	for (i = 0; strcmp(errorstring, xsd_errors[i].errstring) != 0; i++) {
165		if (i == ARRAY_SIZE(xsd_errors) - 1) {
166			pr_warn("xen store gave: unknown error %s\n",
167				errorstring);
168			return EINVAL;
169		}
170	}
171	return xsd_errors[i].errnum;
172}
173
174static bool xenbus_ok(void)
175{
176	switch (xen_store_domain_type) {
177	case XS_LOCAL:
178		switch (system_state) {
179		case SYSTEM_POWER_OFF:
180		case SYSTEM_RESTART:
181		case SYSTEM_HALT:
182			return false;
183		default:
184			break;
185		}
186		return true;
187	case XS_PV:
188	case XS_HVM:
189		/* FIXME: Could check that the remote domain is alive,
190		 * but it is normally initial domain. */
191		return true;
192	default:
193		break;
194	}
195	return false;
196}
197
198static bool test_reply(struct xb_req_data *req)
199{
200	if (req->state == xb_req_state_got_reply || !xenbus_ok()) {
201		/* read req->state before all other fields */
202		virt_rmb();
203		return true;
204	}
205
206	/* Make sure to reread req->state each time. */
207	barrier();
208
209	return false;
210}
211
212static void *read_reply(struct xb_req_data *req)
213{
214	do {
215		wait_event(req->wq, test_reply(req));
216
217		if (!xenbus_ok())
218			/*
219			 * If we are in the process of being shut-down there is
220			 * no point of trying to contact XenBus - it is either
221			 * killed (xenstored application) or the other domain
222			 * has been killed or is unreachable.
223			 */
224			return ERR_PTR(-EIO);
225		if (req->err)
226			return ERR_PTR(req->err);
227
228	} while (req->state != xb_req_state_got_reply);
229
230	return req->body;
231}
232
233static void xs_send(struct xb_req_data *req, struct xsd_sockmsg *msg)
234{
235	bool notify;
236
237	req->msg = *msg;
238	req->err = 0;
239	req->state = xb_req_state_queued;
240	init_waitqueue_head(&req->wq);
241
242	/* Save the caller req_id and restore it later in the reply */
243	req->caller_req_id = req->msg.req_id;
244	req->msg.req_id = xs_request_enter(req);
245
246	/*
247	 * Take 2nd ref.  One for this thread, and the second for the
248	 * xenbus_thread.
249	 */
250	kref_get(&req->kref);
251
252	mutex_lock(&xb_write_mutex);
253	list_add_tail(&req->list, &xb_write_list);
254	notify = list_is_singular(&xb_write_list);
255	mutex_unlock(&xb_write_mutex);
256
257	if (notify)
258		wake_up(&xb_waitq);
259}
260
261static void *xs_wait_for_reply(struct xb_req_data *req, struct xsd_sockmsg *msg)
262{
263	void *ret;
264
265	ret = read_reply(req);
266
267	xs_request_exit(req);
268
269	msg->type = req->msg.type;
270	msg->len = req->msg.len;
271
272	mutex_lock(&xb_write_mutex);
273	if (req->state == xb_req_state_queued ||
274	    req->state == xb_req_state_wait_reply)
275		req->state = xb_req_state_aborted;
276
277	kref_put(&req->kref, xs_free_req);
278	mutex_unlock(&xb_write_mutex);
279
280	return ret;
281}
282
283static void xs_wake_up(struct xb_req_data *req)
284{
285	wake_up(&req->wq);
286}
287
288int xenbus_dev_request_and_reply(struct xsd_sockmsg *msg, void *par)
289{
290	struct xb_req_data *req;
291	struct kvec *vec;
292
293	req = kmalloc(sizeof(*req) + sizeof(*vec), GFP_KERNEL);
294	if (!req)
295		return -ENOMEM;
296
297	vec = (struct kvec *)(req + 1);
298	vec->iov_len = msg->len;
299	vec->iov_base = msg + 1;
300
301	req->vec = vec;
302	req->num_vecs = 1;
303	req->cb = xenbus_dev_queue_reply;
304	req->par = par;
305	req->user_req = true;
306	kref_init(&req->kref);
307
308	xs_send(req, msg);
309
310	return 0;
311}
312EXPORT_SYMBOL(xenbus_dev_request_and_reply);
313
314/* Send message to xs, get kmalloc'ed reply.  ERR_PTR() on error. */
315static void *xs_talkv(struct xenbus_transaction t,
316		      enum xsd_sockmsg_type type,
317		      const struct kvec *iovec,
318		      unsigned int num_vecs,
319		      unsigned int *len)
320{
321	struct xb_req_data *req;
322	struct xsd_sockmsg msg;
323	void *ret = NULL;
324	unsigned int i;
325	int err;
326
327	req = kmalloc(sizeof(*req), GFP_NOIO | __GFP_HIGH);
328	if (!req)
329		return ERR_PTR(-ENOMEM);
330
331	req->vec = iovec;
332	req->num_vecs = num_vecs;
333	req->cb = xs_wake_up;
334	req->user_req = false;
335	kref_init(&req->kref);
336
337	msg.req_id = 0;
338	msg.tx_id = t.id;
339	msg.type = type;
340	msg.len = 0;
341	for (i = 0; i < num_vecs; i++)
342		msg.len += iovec[i].iov_len;
343
344	xs_send(req, &msg);
345
346	ret = xs_wait_for_reply(req, &msg);
347	if (len)
348		*len = msg.len;
349
350	if (IS_ERR(ret))
351		return ret;
352
353	if (msg.type == XS_ERROR) {
354		err = get_error(ret);
355		kfree(ret);
356		return ERR_PTR(-err);
357	}
358
359	if (msg.type != type) {
360		pr_warn_ratelimited("unexpected type [%d], expected [%d]\n",
361				    msg.type, type);
362		kfree(ret);
363		return ERR_PTR(-EINVAL);
364	}
365	return ret;
366}
367
368/* Simplified version of xs_talkv: single message. */
369static void *xs_single(struct xenbus_transaction t,
370		       enum xsd_sockmsg_type type,
371		       const char *string,
372		       unsigned int *len)
373{
374	struct kvec iovec;
375
376	iovec.iov_base = (void *)string;
377	iovec.iov_len = strlen(string) + 1;
378	return xs_talkv(t, type, &iovec, 1, len);
379}
380
381/* Many commands only need an ack, don't care what it says. */
382static int xs_error(char *reply)
383{
384	if (IS_ERR(reply))
385		return PTR_ERR(reply);
386	kfree(reply);
387	return 0;
388}
389
390static unsigned int count_strings(const char *strings, unsigned int len)
391{
392	unsigned int num;
393	const char *p;
394
395	for (p = strings, num = 0; p < strings + len; p += strlen(p) + 1)
396		num++;
397
398	return num;
399}
400
401/* Return the path to dir with /name appended. Buffer must be kfree()'ed. */
402static char *join(const char *dir, const char *name)
403{
404	char *buffer;
405
406	if (strlen(name) == 0)
407		buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s", dir);
408	else
409		buffer = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/%s", dir, name);
410	return buffer ?: ERR_PTR(-ENOMEM);
411}
412
413static char **split_strings(char *strings, unsigned int len, unsigned int *num)
414{
415	char *p, **ret;
416
417	/* Count the strings. */
418	*num = count_strings(strings, len);
419
420	/* Transfer to one big alloc for easy freeing. */
421	ret = kmalloc(*num * sizeof(char *) + len, GFP_NOIO | __GFP_HIGH);
422	if (!ret) {
423		kfree(strings);
424		return ERR_PTR(-ENOMEM);
425	}
426	memcpy(&ret[*num], strings, len);
427	kfree(strings);
428
429	strings = (char *)&ret[*num];
430	for (p = strings, *num = 0; p < strings + len; p += strlen(p) + 1)
431		ret[(*num)++] = p;
432
433	return ret;
434}
435
436char **xenbus_directory(struct xenbus_transaction t,
437			const char *dir, const char *node, unsigned int *num)
438{
439	char *strings, *path;
440	unsigned int len;
441
442	path = join(dir, node);
443	if (IS_ERR(path))
444		return ERR_CAST(path);
445
446	strings = xs_single(t, XS_DIRECTORY, path, &len);
447	kfree(path);
448	if (IS_ERR(strings))
449		return ERR_CAST(strings);
450
451	return split_strings(strings, len, num);
452}
453EXPORT_SYMBOL_GPL(xenbus_directory);
454
455/* Check if a path exists. Return 1 if it does. */
456int xenbus_exists(struct xenbus_transaction t,
457		  const char *dir, const char *node)
458{
459	char **d;
460	int dir_n;
461
462	d = xenbus_directory(t, dir, node, &dir_n);
463	if (IS_ERR(d))
464		return 0;
465	kfree(d);
466	return 1;
467}
468EXPORT_SYMBOL_GPL(xenbus_exists);
469
470/* Get the value of a single file.
471 * Returns a kmalloced value: call free() on it after use.
472 * len indicates length in bytes.
473 */
474void *xenbus_read(struct xenbus_transaction t,
475		  const char *dir, const char *node, unsigned int *len)
476{
477	char *path;
478	void *ret;
479
480	path = join(dir, node);
481	if (IS_ERR(path))
482		return ERR_CAST(path);
483
484	ret = xs_single(t, XS_READ, path, len);
485	kfree(path);
486	return ret;
487}
488EXPORT_SYMBOL_GPL(xenbus_read);
489
490/* Write the value of a single file.
491 * Returns -err on failure.
492 */
493int xenbus_write(struct xenbus_transaction t,
494		 const char *dir, const char *node, const char *string)
495{
496	const char *path;
497	struct kvec iovec[2];
498	int ret;
499
500	path = join(dir, node);
501	if (IS_ERR(path))
502		return PTR_ERR(path);
503
504	iovec[0].iov_base = (void *)path;
505	iovec[0].iov_len = strlen(path) + 1;
506	iovec[1].iov_base = (void *)string;
507	iovec[1].iov_len = strlen(string);
508
509	ret = xs_error(xs_talkv(t, XS_WRITE, iovec, ARRAY_SIZE(iovec), NULL));
510	kfree(path);
511	return ret;
512}
513EXPORT_SYMBOL_GPL(xenbus_write);
514
515/* Destroy a file or directory (directories must be empty). */
516int xenbus_rm(struct xenbus_transaction t, const char *dir, const char *node)
517{
518	char *path;
519	int ret;
520
521	path = join(dir, node);
522	if (IS_ERR(path))
523		return PTR_ERR(path);
524
525	ret = xs_error(xs_single(t, XS_RM, path, NULL));
526	kfree(path);
527	return ret;
528}
529EXPORT_SYMBOL_GPL(xenbus_rm);
530
531/* Start a transaction: changes by others will not be seen during this
532 * transaction, and changes will not be visible to others until end.
533 */
534int xenbus_transaction_start(struct xenbus_transaction *t)
535{
536	char *id_str;
537
538	id_str = xs_single(XBT_NIL, XS_TRANSACTION_START, "", NULL);
539	if (IS_ERR(id_str))
540		return PTR_ERR(id_str);
541
542	t->id = simple_strtoul(id_str, NULL, 0);
543	kfree(id_str);
544	return 0;
545}
546EXPORT_SYMBOL_GPL(xenbus_transaction_start);
547
548/* End a transaction.
549 * If abort is true, transaction is discarded instead of committed.
550 */
551int xenbus_transaction_end(struct xenbus_transaction t, bool abort)
552{
553	return xs_error(xs_single(t, XS_TRANSACTION_END, abort ? "F" : "T",
554				  NULL));
555}
556EXPORT_SYMBOL_GPL(xenbus_transaction_end);
557
558/* Single read and scanf: returns -errno or num scanned. */
559int xenbus_scanf(struct xenbus_transaction t,
560		 const char *dir, const char *node, const char *fmt, ...)
561{
562	va_list ap;
563	int ret;
564	char *val;
565
566	val = xenbus_read(t, dir, node, NULL);
567	if (IS_ERR(val))
568		return PTR_ERR(val);
569
570	va_start(ap, fmt);
571	ret = vsscanf(val, fmt, ap);
572	va_end(ap);
573	kfree(val);
574	/* Distinctive errno. */
575	if (ret == 0)
576		return -ERANGE;
577	return ret;
578}
579EXPORT_SYMBOL_GPL(xenbus_scanf);
580
581/* Read an (optional) unsigned value. */
582unsigned int xenbus_read_unsigned(const char *dir, const char *node,
583				  unsigned int default_val)
584{
585	unsigned int val;
586	int ret;
587
588	ret = xenbus_scanf(XBT_NIL, dir, node, "%u", &val);
589	if (ret <= 0)
590		val = default_val;
591
592	return val;
593}
594EXPORT_SYMBOL_GPL(xenbus_read_unsigned);
595
596/* Single printf and write: returns -errno or 0. */
597int xenbus_printf(struct xenbus_transaction t,
598		  const char *dir, const char *node, const char *fmt, ...)
599{
600	va_list ap;
601	int ret;
602	char *buf;
603
604	va_start(ap, fmt);
605	buf = kvasprintf(GFP_NOIO | __GFP_HIGH, fmt, ap);
606	va_end(ap);
607
608	if (!buf)
609		return -ENOMEM;
610
611	ret = xenbus_write(t, dir, node, buf);
612
613	kfree(buf);
614
615	return ret;
616}
617EXPORT_SYMBOL_GPL(xenbus_printf);
618
619/* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
620int xenbus_gather(struct xenbus_transaction t, const char *dir, ...)
621{
622	va_list ap;
623	const char *name;
624	int ret = 0;
625
626	va_start(ap, dir);
627	while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
628		const char *fmt = va_arg(ap, char *);
629		void *result = va_arg(ap, void *);
630		char *p;
631
632		p = xenbus_read(t, dir, name, NULL);
633		if (IS_ERR(p)) {
634			ret = PTR_ERR(p);
635			break;
636		}
637		if (fmt) {
638			if (sscanf(p, fmt, result) == 0)
639				ret = -EINVAL;
640			kfree(p);
641		} else
642			*(char **)result = p;
643	}
644	va_end(ap);
645	return ret;
646}
647EXPORT_SYMBOL_GPL(xenbus_gather);
648
649static int xs_watch(const char *path, const char *token)
650{
651	struct kvec iov[2];
652
653	iov[0].iov_base = (void *)path;
654	iov[0].iov_len = strlen(path) + 1;
655	iov[1].iov_base = (void *)token;
656	iov[1].iov_len = strlen(token) + 1;
657
658	return xs_error(xs_talkv(XBT_NIL, XS_WATCH, iov,
659				 ARRAY_SIZE(iov), NULL));
660}
661
662static int xs_unwatch(const char *path, const char *token)
663{
664	struct kvec iov[2];
665
666	iov[0].iov_base = (char *)path;
667	iov[0].iov_len = strlen(path) + 1;
668	iov[1].iov_base = (char *)token;
669	iov[1].iov_len = strlen(token) + 1;
670
671	return xs_error(xs_talkv(XBT_NIL, XS_UNWATCH, iov,
672				 ARRAY_SIZE(iov), NULL));
673}
674
675static struct xenbus_watch *find_watch(const char *token)
676{
677	struct xenbus_watch *i, *cmp;
678
679	cmp = (void *)simple_strtoul(token, NULL, 16);
680
681	list_for_each_entry(i, &watches, list)
682		if (i == cmp)
683			return i;
684
685	return NULL;
686}
687
688int xs_watch_msg(struct xs_watch_event *event)
689{
690	if (count_strings(event->body, event->len) != 2) {
691		kfree(event);
692		return -EINVAL;
693	}
694	event->path = (const char *)event->body;
695	event->token = (const char *)strchr(event->body, '\0') + 1;
696
697	spin_lock(&watches_lock);
698	event->handle = find_watch(event->token);
699	if (event->handle != NULL &&
700			(!event->handle->will_handle ||
701			 event->handle->will_handle(event->handle,
702				 event->path, event->token))) {
703		spin_lock(&watch_events_lock);
704		list_add_tail(&event->list, &watch_events);
705		event->handle->nr_pending++;
706		wake_up(&watch_events_waitq);
707		spin_unlock(&watch_events_lock);
708	} else
709		kfree(event);
710	spin_unlock(&watches_lock);
711
712	return 0;
713}
714
715static void xs_reset_watches(void)
716{
717	int err;
718
719	if (!xen_hvm_domain() || xen_initial_domain())
720		return;
721
722	if (!xenbus_read_unsigned("control",
723				  "platform-feature-xs_reset_watches", 0))
724		return;
725
726	err = xs_error(xs_single(XBT_NIL, XS_RESET_WATCHES, "", NULL));
727	if (err && err != -EEXIST)
728		pr_warn("xs_reset_watches failed: %d\n", err);
729}
730
731/* Register callback to watch this node. */
732int register_xenbus_watch(struct xenbus_watch *watch)
733{
734	/* Pointer in ascii is the token. */
735	char token[sizeof(watch) * 2 + 1];
736	int err;
737
738	sprintf(token, "%lX", (long)watch);
739
740	watch->nr_pending = 0;
741
742	down_read(&xs_watch_rwsem);
743
744	spin_lock(&watches_lock);
745	BUG_ON(find_watch(token));
746	list_add(&watch->list, &watches);
747	spin_unlock(&watches_lock);
748
749	err = xs_watch(watch->node, token);
750
751	if (err) {
752		spin_lock(&watches_lock);
753		list_del(&watch->list);
754		spin_unlock(&watches_lock);
755	}
756
757	up_read(&xs_watch_rwsem);
758
759	return err;
760}
761EXPORT_SYMBOL_GPL(register_xenbus_watch);
762
763void unregister_xenbus_watch(struct xenbus_watch *watch)
764{
765	struct xs_watch_event *event, *tmp;
766	char token[sizeof(watch) * 2 + 1];
767	int err;
768
769	sprintf(token, "%lX", (long)watch);
770
771	down_read(&xs_watch_rwsem);
772
773	spin_lock(&watches_lock);
774	BUG_ON(!find_watch(token));
775	list_del(&watch->list);
776	spin_unlock(&watches_lock);
777
778	err = xs_unwatch(watch->node, token);
779	if (err)
780		pr_warn("Failed to release watch %s: %i\n", watch->node, err);
781
782	up_read(&xs_watch_rwsem);
783
784	/* Make sure there are no callbacks running currently (unless
785	   its us) */
786	if (current->pid != xenwatch_pid)
787		mutex_lock(&xenwatch_mutex);
788
789	/* Cancel pending watch events. */
790	spin_lock(&watch_events_lock);
791	if (watch->nr_pending) {
792		list_for_each_entry_safe(event, tmp, &watch_events, list) {
793			if (event->handle != watch)
794				continue;
795			list_del(&event->list);
796			kfree(event);
797		}
798		watch->nr_pending = 0;
799	}
800	spin_unlock(&watch_events_lock);
801
802	if (current->pid != xenwatch_pid)
803		mutex_unlock(&xenwatch_mutex);
804}
805EXPORT_SYMBOL_GPL(unregister_xenbus_watch);
806
807void xs_suspend(void)
808{
809	xs_suspend_enter();
810
811	mutex_lock(&xs_response_mutex);
812	down_write(&xs_watch_rwsem);
813}
814
815void xs_resume(void)
816{
817	struct xenbus_watch *watch;
818	char token[sizeof(watch) * 2 + 1];
819
820	xb_init_comms();
821
822	mutex_unlock(&xs_response_mutex);
823
824	xs_suspend_exit();
825
826	/* No need for watches_lock: the xs_watch_rwsem is sufficient. */
827	list_for_each_entry(watch, &watches, list) {
828		sprintf(token, "%lX", (long)watch);
829		xs_watch(watch->node, token);
830	}
831
832	up_write(&xs_watch_rwsem);
833}
834
835void xs_suspend_cancel(void)
836{
837	up_write(&xs_watch_rwsem);
838	mutex_unlock(&xs_response_mutex);
839
840	xs_suspend_exit();
841}
842
843static int xenwatch_thread(void *unused)
844{
845	struct xs_watch_event *event;
846
847	xenwatch_pid = current->pid;
848
849	for (;;) {
850		wait_event_interruptible(watch_events_waitq,
851					 !list_empty(&watch_events));
852
853		if (kthread_should_stop())
854			break;
855
856		mutex_lock(&xenwatch_mutex);
857
858		spin_lock(&watch_events_lock);
859		event = list_first_entry_or_null(&watch_events,
860				struct xs_watch_event, list);
861		if (event) {
862			list_del(&event->list);
863			event->handle->nr_pending--;
864		}
865		spin_unlock(&watch_events_lock);
866
867		if (event) {
868			event->handle->callback(event->handle, event->path,
869						event->token);
870			kfree(event);
871		}
872
873		mutex_unlock(&xenwatch_mutex);
874	}
875
876	return 0;
877}
878
879/*
880 * Wake up all threads waiting for a xenstore reply. In case of shutdown all
881 * pending replies will be marked as "aborted" in order to let the waiters
882 * return in spite of xenstore possibly no longer being able to reply. This
883 * will avoid blocking shutdown by a thread waiting for xenstore but being
884 * necessary for shutdown processing to proceed.
885 */
886static int xs_reboot_notify(struct notifier_block *nb,
887			    unsigned long code, void *unused)
888{
889	struct xb_req_data *req;
890
891	mutex_lock(&xb_write_mutex);
892	list_for_each_entry(req, &xs_reply_list, list)
893		wake_up(&req->wq);
894	list_for_each_entry(req, &xb_write_list, list)
895		wake_up(&req->wq);
896	mutex_unlock(&xb_write_mutex);
897	return NOTIFY_DONE;
898}
899
900static struct notifier_block xs_reboot_nb = {
901	.notifier_call = xs_reboot_notify,
902};
903
904int xs_init(void)
905{
906	int err;
907	struct task_struct *task;
908
909	register_reboot_notifier(&xs_reboot_nb);
910
911	/* Initialize the shared memory rings to talk to xenstored */
912	err = xb_init_comms();
913	if (err)
914		return err;
915
916	task = kthread_run(xenwatch_thread, NULL, "xenwatch");
917	if (IS_ERR(task))
918		return PTR_ERR(task);
919
920	/* shutdown watches for kexec boot */
921	xs_reset_watches();
922
923	return 0;
924}