xref: /linux/drivers/xen/xenbus/xenbus_comms.c (revision a1c3be890440a1769ed6f822376a3e3ab0d42994) 
1 /******************************************************************************
2  * xenbus_comms.c
3  *
4  * Low level code to talks to Xen Store: ringbuffer and event channel.
5  *
6  * Copyright (C) 2005 Rusty Russell, IBM Corporation
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License version 2
10  * as published by the Free Software Foundation; or, when distributed
11  * separately from the Linux kernel or incorporated into other
12  * software packages, subject to the following license:
13  *
14  * Permission is hereby granted, free of charge, to any person obtaining a copy
15  * of this source file (the "Software"), to deal in the Software without
16  * restriction, including without limitation the rights to use, copy, modify,
17  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
18  * and to permit persons to whom the Software is furnished to do so, subject to
19  * the following conditions:
20  *
21  * The above copyright notice and this permission notice shall be included in
22  * all copies or substantial portions of the Software.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
30  * IN THE SOFTWARE.
31  */
32 
33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34 
35 #include <linux/wait.h>
36 #include <linux/interrupt.h>
37 #include <linux/kthread.h>
38 #include <linux/sched.h>
39 #include <linux/err.h>
40 #include <xen/xenbus.h>
41 #include <asm/xen/hypervisor.h>
42 #include <xen/events.h>
43 #include <xen/page.h>
44 #include "xenbus.h"
45 
46 /* A list of replies. Currently only one will ever be outstanding. */
47 LIST_HEAD(xs_reply_list);
48 
49 /* A list of write requests. */
50 LIST_HEAD(xb_write_list);
51 DECLARE_WAIT_QUEUE_HEAD(xb_waitq);
52 DEFINE_MUTEX(xb_write_mutex);
53 
54 /* Protect xenbus reader thread against save/restore. */
55 DEFINE_MUTEX(xs_response_mutex);
56 
57 static int xenbus_irq;
58 static struct task_struct *xenbus_task;
59 
60 static irqreturn_t wake_waiting(int irq, void *unused)
61 {
62 	wake_up(&xb_waitq);
63 	return IRQ_HANDLED;
64 }
65 
66 static int check_indexes(XENSTORE_RING_IDX cons, XENSTORE_RING_IDX prod)
67 {
68 	return ((prod - cons) <= XENSTORE_RING_SIZE);
69 }
70 
71 static void *get_output_chunk(XENSTORE_RING_IDX cons,
72 			      XENSTORE_RING_IDX prod,
73 			      char *buf, uint32_t *len)
74 {
75 	*len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod);
76 	if ((XENSTORE_RING_SIZE - (prod - cons)) < *len)
77 		*len = XENSTORE_RING_SIZE - (prod - cons);
78 	return buf + MASK_XENSTORE_IDX(prod);
79 }
80 
81 static const void *get_input_chunk(XENSTORE_RING_IDX cons,
82 				   XENSTORE_RING_IDX prod,
83 				   const char *buf, uint32_t *len)
84 {
85 	*len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(cons);
86 	if ((prod - cons) < *len)
87 		*len = prod - cons;
88 	return buf + MASK_XENSTORE_IDX(cons);
89 }
90 
91 static int xb_data_to_write(void)
92 {
93 	struct xenstore_domain_interface *intf = xen_store_interface;
94 
95 	return (intf->req_prod - intf->req_cons) != XENSTORE_RING_SIZE &&
96 		!list_empty(&xb_write_list);
97 }
98 
99 /**
100  * xb_write - low level write
101  * @data: buffer to send
102  * @len: length of buffer
103  *
104  * Returns number of bytes written or -err.
105  */
106 static int xb_write(const void *data, unsigned int len)
107 {
108 	struct xenstore_domain_interface *intf = xen_store_interface;
109 	XENSTORE_RING_IDX cons, prod;
110 	unsigned int bytes = 0;
111 
112 	while (len != 0) {
113 		void *dst;
114 		unsigned int avail;
115 
116 		/* Read indexes, then verify. */
117 		cons = intf->req_cons;
118 		prod = intf->req_prod;
119 		if (!check_indexes(cons, prod)) {
120 			intf->req_cons = intf->req_prod = 0;
121 			return -EIO;
122 		}
123 		if (!xb_data_to_write())
124 			return bytes;
125 
126 		/* Must write data /after/ reading the consumer index. */
127 		virt_mb();
128 
129 		dst = get_output_chunk(cons, prod, intf->req, &avail);
130 		if (avail == 0)
131 			continue;
132 		if (avail > len)
133 			avail = len;
134 
135 		memcpy(dst, data, avail);
136 		data += avail;
137 		len -= avail;
138 		bytes += avail;
139 
140 		/* Other side must not see new producer until data is there. */
141 		virt_wmb();
142 		intf->req_prod += avail;
143 
144 		/* Implies mb(): other side will see the updated producer. */
145 		if (prod <= intf->req_cons)
146 			notify_remote_via_evtchn(xen_store_evtchn);
147 	}
148 
149 	return bytes;
150 }
151 
152 static int xb_data_to_read(void)
153 {
154 	struct xenstore_domain_interface *intf = xen_store_interface;
155 	return (intf->rsp_cons != intf->rsp_prod);
156 }
157 
158 static int xb_read(void *data, unsigned int len)
159 {
160 	struct xenstore_domain_interface *intf = xen_store_interface;
161 	XENSTORE_RING_IDX cons, prod;
162 	unsigned int bytes = 0;
163 
164 	while (len != 0) {
165 		unsigned int avail;
166 		const char *src;
167 
168 		/* Read indexes, then verify. */
169 		cons = intf->rsp_cons;
170 		prod = intf->rsp_prod;
171 		if (cons == prod)
172 			return bytes;
173 
174 		if (!check_indexes(cons, prod)) {
175 			intf->rsp_cons = intf->rsp_prod = 0;
176 			return -EIO;
177 		}
178 
179 		src = get_input_chunk(cons, prod, intf->rsp, &avail);
180 		if (avail == 0)
181 			continue;
182 		if (avail > len)
183 			avail = len;
184 
185 		/* Must read data /after/ reading the producer index. */
186 		virt_rmb();
187 
188 		memcpy(data, src, avail);
189 		data += avail;
190 		len -= avail;
191 		bytes += avail;
192 
193 		/* Other side must not see free space until we've copied out */
194 		virt_mb();
195 		intf->rsp_cons += avail;
196 
197 		/* Implies mb(): other side will see the updated consumer. */
198 		if (intf->rsp_prod - cons >= XENSTORE_RING_SIZE)
199 			notify_remote_via_evtchn(xen_store_evtchn);
200 	}
201 
202 	return bytes;
203 }
204 
205 static int process_msg(void)
206 {
207 	static struct {
208 		struct xsd_sockmsg msg;
209 		char *body;
210 		union {
211 			void *alloc;
212 			struct xs_watch_event *watch;
213 		};
214 		bool in_msg;
215 		bool in_hdr;
216 		unsigned int read;
217 	} state;
218 	struct xb_req_data *req;
219 	int err;
220 	unsigned int len;
221 
222 	if (!state.in_msg) {
223 		state.in_msg = true;
224 		state.in_hdr = true;
225 		state.read = 0;
226 
227 		/*
228 		 * We must disallow save/restore while reading a message.
229 		 * A partial read across s/r leaves us out of sync with
230 		 * xenstored.
231 		 * xs_response_mutex is locked as long as we are processing one
232 		 * message. state.in_msg will be true as long as we are holding
233 		 * the lock here.
234 		 */
235 		mutex_lock(&xs_response_mutex);
236 
237 		if (!xb_data_to_read()) {
238 			/* We raced with save/restore: pending data 'gone'. */
239 			mutex_unlock(&xs_response_mutex);
240 			state.in_msg = false;
241 			return 0;
242 		}
243 	}
244 
245 	if (state.in_hdr) {
246 		if (state.read != sizeof(state.msg)) {
247 			err = xb_read((void *)&state.msg + state.read,
248 				      sizeof(state.msg) - state.read);
249 			if (err < 0)
250 				goto out;
251 			state.read += err;
252 			if (state.read != sizeof(state.msg))
253 				return 0;
254 			if (state.msg.len > XENSTORE_PAYLOAD_MAX) {
255 				err = -EINVAL;
256 				goto out;
257 			}
258 		}
259 
260 		len = state.msg.len + 1;
261 		if (state.msg.type == XS_WATCH_EVENT)
262 			len += sizeof(*state.watch);
263 
264 		state.alloc = kmalloc(len, GFP_NOIO | __GFP_HIGH);
265 		if (!state.alloc)
266 			return -ENOMEM;
267 
268 		if (state.msg.type == XS_WATCH_EVENT)
269 			state.body = state.watch->body;
270 		else
271 			state.body = state.alloc;
272 		state.in_hdr = false;
273 		state.read = 0;
274 	}
275 
276 	err = xb_read(state.body + state.read, state.msg.len - state.read);
277 	if (err < 0)
278 		goto out;
279 
280 	state.read += err;
281 	if (state.read != state.msg.len)
282 		return 0;
283 
284 	state.body[state.msg.len] = '\0';
285 
286 	if (state.msg.type == XS_WATCH_EVENT) {
287 		state.watch->len = state.msg.len;
288 		err = xs_watch_msg(state.watch);
289 	} else {
290 		err = -ENOENT;
291 		mutex_lock(&xb_write_mutex);
292 		list_for_each_entry(req, &xs_reply_list, list) {
293 			if (req->msg.req_id == state.msg.req_id) {
294 				list_del(&req->list);
295 				err = 0;
296 				break;
297 			}
298 		}
299 		mutex_unlock(&xb_write_mutex);
300 		if (err)
301 			goto out;
302 
303 		if (req->state == xb_req_state_wait_reply) {
304 			req->msg.req_id = req->caller_req_id;
305 			req->msg.type = state.msg.type;
306 			req->msg.len = state.msg.len;
307 			req->body = state.body;
308 			/* write body, then update state */
309 			virt_wmb();
310 			req->state = xb_req_state_got_reply;
311 			req->cb(req);
312 		} else
313 			kfree(req);
314 	}
315 
316 	mutex_unlock(&xs_response_mutex);
317 
318 	state.in_msg = false;
319 	state.alloc = NULL;
320 	return err;
321 
322  out:
323 	mutex_unlock(&xs_response_mutex);
324 	state.in_msg = false;
325 	kfree(state.alloc);
326 	state.alloc = NULL;
327 	return err;
328 }
329 
330 static int process_writes(void)
331 {
332 	static struct {
333 		struct xb_req_data *req;
334 		int idx;
335 		unsigned int written;
336 	} state;
337 	void *base;
338 	unsigned int len;
339 	int err = 0;
340 
341 	if (!xb_data_to_write())
342 		return 0;
343 
344 	mutex_lock(&xb_write_mutex);
345 
346 	if (!state.req) {
347 		state.req = list_first_entry(&xb_write_list,
348 					     struct xb_req_data, list);
349 		state.idx = -1;
350 		state.written = 0;
351 	}
352 
353 	if (state.req->state == xb_req_state_aborted)
354 		goto out_err;
355 
356 	while (state.idx < state.req->num_vecs) {
357 		if (state.idx < 0) {
358 			base = &state.req->msg;
359 			len = sizeof(state.req->msg);
360 		} else {
361 			base = state.req->vec[state.idx].iov_base;
362 			len = state.req->vec[state.idx].iov_len;
363 		}
364 		err = xb_write(base + state.written, len - state.written);
365 		if (err < 0)
366 			goto out_err;
367 		state.written += err;
368 		if (state.written != len)
369 			goto out;
370 
371 		state.idx++;
372 		state.written = 0;
373 	}
374 
375 	list_del(&state.req->list);
376 	state.req->state = xb_req_state_wait_reply;
377 	list_add_tail(&state.req->list, &xs_reply_list);
378 	state.req = NULL;
379 
380  out:
381 	mutex_unlock(&xb_write_mutex);
382 
383 	return 0;
384 
385  out_err:
386 	state.req->msg.type = XS_ERROR;
387 	state.req->err = err;
388 	list_del(&state.req->list);
389 	if (state.req->state == xb_req_state_aborted)
390 		kfree(state.req);
391 	else {
392 		/* write err, then update state */
393 		virt_wmb();
394 		state.req->state = xb_req_state_got_reply;
395 		wake_up(&state.req->wq);
396 	}
397 
398 	mutex_unlock(&xb_write_mutex);
399 
400 	state.req = NULL;
401 
402 	return err;
403 }
404 
405 static int xb_thread_work(void)
406 {
407 	return xb_data_to_read() || xb_data_to_write();
408 }
409 
410 static int xenbus_thread(void *unused)
411 {
412 	int err;
413 
414 	while (!kthread_should_stop()) {
415 		if (wait_event_interruptible(xb_waitq, xb_thread_work()))
416 			continue;
417 
418 		err = process_msg();
419 		if (err == -ENOMEM)
420 			schedule();
421 		else if (err)
422 			pr_warn_ratelimited("error %d while reading message\n",
423 					    err);
424 
425 		err = process_writes();
426 		if (err)
427 			pr_warn_ratelimited("error %d while writing message\n",
428 					    err);
429 	}
430 
431 	xenbus_task = NULL;
432 	return 0;
433 }
434 
435 /**
436  * xb_init_comms - Set up interrupt handler off store event channel.
437  */
438 int xb_init_comms(void)
439 {
440 	struct xenstore_domain_interface *intf = xen_store_interface;
441 
442 	if (intf->req_prod != intf->req_cons)
443 		pr_err("request ring is not quiescent (%08x:%08x)!\n",
444 		       intf->req_cons, intf->req_prod);
445 
446 	if (intf->rsp_prod != intf->rsp_cons) {
447 		pr_warn("response ring is not quiescent (%08x:%08x): fixing up\n",
448 			intf->rsp_cons, intf->rsp_prod);
449 		/* breaks kdump */
450 		if (!reset_devices)
451 			intf->rsp_cons = intf->rsp_prod;
452 	}
453 
454 	if (xenbus_irq) {
455 		/* Already have an irq; assume we're resuming */
456 		rebind_evtchn_irq(xen_store_evtchn, xenbus_irq);
457 	} else {
458 		int err;
459 
460 		err = bind_evtchn_to_irqhandler(xen_store_evtchn, wake_waiting,
461 						0, "xenbus", &xb_waitq);
462 		if (err < 0) {
463 			pr_err("request irq failed %i\n", err);
464 			return err;
465 		}
466 
467 		xenbus_irq = err;
468 
469 		if (!xenbus_task) {
470 			xenbus_task = kthread_run(xenbus_thread, NULL,
471 						  "xenbus");
472 			if (IS_ERR(xenbus_task))
473 				return PTR_ERR(xenbus_task);
474 		}
475 	}
476 
477 	return 0;
478 }
479 
480 void xb_deinit_comms(void)
481 {
482 	unbind_from_irqhandler(xenbus_irq, &xb_waitq);
483 	xenbus_irq = 0;
484 }
485