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