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 
xs_suspend_enter(void)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 
xs_suspend_exit(void)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 
xs_request_enter(struct xb_req_data * req)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 
xs_request_exit(struct xb_req_data * req)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 
get_error(const char * errorstring)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 
xenbus_ok(void)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 
test_reply(struct xb_req_data * req)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 
read_reply(struct xb_req_data * req)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 
xs_send(struct xb_req_data * req,struct xsd_sockmsg * msg)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 
xs_wait_for_reply(struct xb_req_data * req,struct xsd_sockmsg * msg)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 
xs_wake_up(struct xb_req_data * req)271 static void xs_wake_up(struct xb_req_data *req)
272 {
273 	wake_up(&req->wq);
274 }
275 
xenbus_dev_request_and_reply(struct xsd_sockmsg * msg,void * par)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. */
xs_talkv(struct xenbus_transaction t,enum xsd_sockmsg_type type,const struct kvec * iovec,unsigned int num_vecs,unsigned int * len)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. */
xs_single(struct xenbus_transaction t,enum xsd_sockmsg_type type,const char * string,unsigned int * len)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. */
xs_error(char * reply)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 
count_strings(const char * strings,unsigned int len)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. */
join(const char * dir,const char * name)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 
split(char * strings,unsigned int len,unsigned int * num)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 
xenbus_directory(struct xenbus_transaction t,const char * dir,const char * node,unsigned int * num)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. */
xenbus_exists(struct xenbus_transaction t,const char * dir,const char * node)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  */
xenbus_read(struct xenbus_transaction t,const char * dir,const char * node,unsigned int * len)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  */
xenbus_write(struct xenbus_transaction t,const char * dir,const char * node,const char * string)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. */
xenbus_mkdir(struct xenbus_transaction t,const char * dir,const char * node)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). */
xenbus_rm(struct xenbus_transaction t,const char * dir,const char * node)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  */
xenbus_transaction_start(struct xenbus_transaction * t)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  */
xenbus_transaction_end(struct xenbus_transaction t,int abort)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. */
xenbus_scanf(struct xenbus_transaction t,const char * dir,const char * node,const char * fmt,...)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. */
xenbus_read_unsigned(const char * dir,const char * node,unsigned int default_val)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. */
xenbus_printf(struct xenbus_transaction t,const char * dir,const char * node,const char * fmt,...)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. */
xenbus_gather(struct xenbus_transaction t,const char * dir,...)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 
xs_watch(const char * path,const char * token)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 
xs_unwatch(const char * path,const char * token)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 
find_watch(const char * token)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 
xs_watch_msg(struct xs_watch_event * event)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  */
xen_strict_xenbus_quirk(void)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 }
xs_reset_watches(void)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. */
register_xenbus_watch(struct xenbus_watch * watch)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 
unregister_xenbus_watch(struct xenbus_watch * watch)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 
xs_suspend(void)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 
xs_resume(void)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 
xs_suspend_cancel(void)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 
xenwatch_thread(void * unused)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  */
xs_reboot_notify(struct notifier_block * nb,unsigned long code,void * unused)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 
xs_init(void)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 }
957