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