xref: /linux/drivers/xen/xenbus/xenbus_client.c (revision a4eb44a6435d6d8f9e642407a4a06f65eb90ca04)
1 /******************************************************************************
2  * Client-facing interface for the Xenbus driver.  In other words, the
3  * interface between the Xenbus and the device-specific code, be it the
4  * frontend or the backend of that driver.
5  *
6  * Copyright (C) 2005 XenSource Ltd
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 #include <linux/mm.h>
34 #include <linux/slab.h>
35 #include <linux/types.h>
36 #include <linux/spinlock.h>
37 #include <linux/vmalloc.h>
38 #include <linux/export.h>
39 #include <asm/xen/hypervisor.h>
40 #include <xen/page.h>
41 #include <xen/interface/xen.h>
42 #include <xen/interface/event_channel.h>
43 #include <xen/balloon.h>
44 #include <xen/events.h>
45 #include <xen/grant_table.h>
46 #include <xen/xenbus.h>
47 #include <xen/xen.h>
48 #include <xen/features.h>
49 
50 #include "xenbus.h"
51 
52 #define XENBUS_PAGES(_grants)	(DIV_ROUND_UP(_grants, XEN_PFN_PER_PAGE))
53 
54 #define XENBUS_MAX_RING_PAGES	(XENBUS_PAGES(XENBUS_MAX_RING_GRANTS))
55 
56 struct xenbus_map_node {
57 	struct list_head next;
58 	union {
59 		struct {
60 			struct vm_struct *area;
61 		} pv;
62 		struct {
63 			struct page *pages[XENBUS_MAX_RING_PAGES];
64 			unsigned long addrs[XENBUS_MAX_RING_GRANTS];
65 			void *addr;
66 		} hvm;
67 	};
68 	grant_handle_t handles[XENBUS_MAX_RING_GRANTS];
69 	unsigned int   nr_handles;
70 };
71 
72 struct map_ring_valloc {
73 	struct xenbus_map_node *node;
74 
75 	/* Why do we need two arrays? See comment of __xenbus_map_ring */
76 	unsigned long addrs[XENBUS_MAX_RING_GRANTS];
77 	phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS];
78 
79 	struct gnttab_map_grant_ref map[XENBUS_MAX_RING_GRANTS];
80 	struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
81 
82 	unsigned int idx;
83 };
84 
85 static DEFINE_SPINLOCK(xenbus_valloc_lock);
86 static LIST_HEAD(xenbus_valloc_pages);
87 
88 struct xenbus_ring_ops {
89 	int (*map)(struct xenbus_device *dev, struct map_ring_valloc *info,
90 		   grant_ref_t *gnt_refs, unsigned int nr_grefs,
91 		   void **vaddr);
92 	int (*unmap)(struct xenbus_device *dev, void *vaddr);
93 };
94 
95 static const struct xenbus_ring_ops *ring_ops __read_mostly;
96 
97 const char *xenbus_strstate(enum xenbus_state state)
98 {
99 	static const char *const name[] = {
100 		[ XenbusStateUnknown      ] = "Unknown",
101 		[ XenbusStateInitialising ] = "Initialising",
102 		[ XenbusStateInitWait     ] = "InitWait",
103 		[ XenbusStateInitialised  ] = "Initialised",
104 		[ XenbusStateConnected    ] = "Connected",
105 		[ XenbusStateClosing      ] = "Closing",
106 		[ XenbusStateClosed	  ] = "Closed",
107 		[XenbusStateReconfiguring] = "Reconfiguring",
108 		[XenbusStateReconfigured] = "Reconfigured",
109 	};
110 	return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
111 }
112 EXPORT_SYMBOL_GPL(xenbus_strstate);
113 
114 /**
115  * xenbus_watch_path - register a watch
116  * @dev: xenbus device
117  * @path: path to watch
118  * @watch: watch to register
119  * @callback: callback to register
120  *
121  * Register a @watch on the given path, using the given xenbus_watch structure
122  * for storage, and the given @callback function as the callback.  Return 0 on
123  * success, or -errno on error.  On success, the given @path will be saved as
124  * @watch->node, and remains the caller's to free.  On error, @watch->node will
125  * be NULL, the device will switch to %XenbusStateClosing, and the error will
126  * be saved in the store.
127  */
128 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
129 		      struct xenbus_watch *watch,
130 		      bool (*will_handle)(struct xenbus_watch *,
131 					  const char *, const char *),
132 		      void (*callback)(struct xenbus_watch *,
133 				       const char *, const char *))
134 {
135 	int err;
136 
137 	watch->node = path;
138 	watch->will_handle = will_handle;
139 	watch->callback = callback;
140 
141 	err = register_xenbus_watch(watch);
142 
143 	if (err) {
144 		watch->node = NULL;
145 		watch->will_handle = NULL;
146 		watch->callback = NULL;
147 		xenbus_dev_fatal(dev, err, "adding watch on %s", path);
148 	}
149 
150 	return err;
151 }
152 EXPORT_SYMBOL_GPL(xenbus_watch_path);
153 
154 
155 /**
156  * xenbus_watch_pathfmt - register a watch on a sprintf-formatted path
157  * @dev: xenbus device
158  * @watch: watch to register
159  * @callback: callback to register
160  * @pathfmt: format of path to watch
161  *
162  * Register a watch on the given @path, using the given xenbus_watch
163  * structure for storage, and the given @callback function as the callback.
164  * Return 0 on success, or -errno on error.  On success, the watched path
165  * (@path/@path2) will be saved as @watch->node, and becomes the caller's to
166  * kfree().  On error, watch->node will be NULL, so the caller has nothing to
167  * free, the device will switch to %XenbusStateClosing, and the error will be
168  * saved in the store.
169  */
170 int xenbus_watch_pathfmt(struct xenbus_device *dev,
171 			 struct xenbus_watch *watch,
172 			 bool (*will_handle)(struct xenbus_watch *,
173 					const char *, const char *),
174 			 void (*callback)(struct xenbus_watch *,
175 					  const char *, const char *),
176 			 const char *pathfmt, ...)
177 {
178 	int err;
179 	va_list ap;
180 	char *path;
181 
182 	va_start(ap, pathfmt);
183 	path = kvasprintf(GFP_NOIO | __GFP_HIGH, pathfmt, ap);
184 	va_end(ap);
185 
186 	if (!path) {
187 		xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
188 		return -ENOMEM;
189 	}
190 	err = xenbus_watch_path(dev, path, watch, will_handle, callback);
191 
192 	if (err)
193 		kfree(path);
194 	return err;
195 }
196 EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
197 
198 static void xenbus_switch_fatal(struct xenbus_device *, int, int,
199 				const char *, ...);
200 
201 static int
202 __xenbus_switch_state(struct xenbus_device *dev,
203 		      enum xenbus_state state, int depth)
204 {
205 	/* We check whether the state is currently set to the given value, and
206 	   if not, then the state is set.  We don't want to unconditionally
207 	   write the given state, because we don't want to fire watches
208 	   unnecessarily.  Furthermore, if the node has gone, we don't write
209 	   to it, as the device will be tearing down, and we don't want to
210 	   resurrect that directory.
211 
212 	   Note that, because of this cached value of our state, this
213 	   function will not take a caller's Xenstore transaction
214 	   (something it was trying to in the past) because dev->state
215 	   would not get reset if the transaction was aborted.
216 	 */
217 
218 	struct xenbus_transaction xbt;
219 	int current_state;
220 	int err, abort;
221 
222 	if (state == dev->state)
223 		return 0;
224 
225 again:
226 	abort = 1;
227 
228 	err = xenbus_transaction_start(&xbt);
229 	if (err) {
230 		xenbus_switch_fatal(dev, depth, err, "starting transaction");
231 		return 0;
232 	}
233 
234 	err = xenbus_scanf(xbt, dev->nodename, "state", "%d", &current_state);
235 	if (err != 1)
236 		goto abort;
237 
238 	err = xenbus_printf(xbt, dev->nodename, "state", "%d", state);
239 	if (err) {
240 		xenbus_switch_fatal(dev, depth, err, "writing new state");
241 		goto abort;
242 	}
243 
244 	abort = 0;
245 abort:
246 	err = xenbus_transaction_end(xbt, abort);
247 	if (err) {
248 		if (err == -EAGAIN && !abort)
249 			goto again;
250 		xenbus_switch_fatal(dev, depth, err, "ending transaction");
251 	} else
252 		dev->state = state;
253 
254 	return 0;
255 }
256 
257 /**
258  * xenbus_switch_state
259  * @dev: xenbus device
260  * @state: new state
261  *
262  * Advertise in the store a change of the given driver to the given new_state.
263  * Return 0 on success, or -errno on error.  On error, the device will switch
264  * to XenbusStateClosing, and the error will be saved in the store.
265  */
266 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
267 {
268 	return __xenbus_switch_state(dev, state, 0);
269 }
270 
271 EXPORT_SYMBOL_GPL(xenbus_switch_state);
272 
273 int xenbus_frontend_closed(struct xenbus_device *dev)
274 {
275 	xenbus_switch_state(dev, XenbusStateClosed);
276 	complete(&dev->down);
277 	return 0;
278 }
279 EXPORT_SYMBOL_GPL(xenbus_frontend_closed);
280 
281 static void xenbus_va_dev_error(struct xenbus_device *dev, int err,
282 				const char *fmt, va_list ap)
283 {
284 	unsigned int len;
285 	char *printf_buffer;
286 	char *path_buffer;
287 
288 #define PRINTF_BUFFER_SIZE 4096
289 
290 	printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
291 	if (!printf_buffer)
292 		return;
293 
294 	len = sprintf(printf_buffer, "%i ", -err);
295 	vsnprintf(printf_buffer + len, PRINTF_BUFFER_SIZE - len, fmt, ap);
296 
297 	dev_err(&dev->dev, "%s\n", printf_buffer);
298 
299 	path_buffer = kasprintf(GFP_KERNEL, "error/%s", dev->nodename);
300 	if (path_buffer)
301 		xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer);
302 
303 	kfree(printf_buffer);
304 	kfree(path_buffer);
305 }
306 
307 /**
308  * xenbus_dev_error
309  * @dev: xenbus device
310  * @err: error to report
311  * @fmt: error message format
312  *
313  * Report the given negative errno into the store, along with the given
314  * formatted message.
315  */
316 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...)
317 {
318 	va_list ap;
319 
320 	va_start(ap, fmt);
321 	xenbus_va_dev_error(dev, err, fmt, ap);
322 	va_end(ap);
323 }
324 EXPORT_SYMBOL_GPL(xenbus_dev_error);
325 
326 /**
327  * xenbus_dev_fatal
328  * @dev: xenbus device
329  * @err: error to report
330  * @fmt: error message format
331  *
332  * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
333  * xenbus_switch_state(dev, XenbusStateClosing) to schedule an orderly
334  * closedown of this driver and its peer.
335  */
336 
337 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...)
338 {
339 	va_list ap;
340 
341 	va_start(ap, fmt);
342 	xenbus_va_dev_error(dev, err, fmt, ap);
343 	va_end(ap);
344 
345 	xenbus_switch_state(dev, XenbusStateClosing);
346 }
347 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
348 
349 /**
350  * Equivalent to xenbus_dev_fatal(dev, err, fmt, args), but helps
351  * avoiding recursion within xenbus_switch_state.
352  */
353 static void xenbus_switch_fatal(struct xenbus_device *dev, int depth, int err,
354 				const char *fmt, ...)
355 {
356 	va_list ap;
357 
358 	va_start(ap, fmt);
359 	xenbus_va_dev_error(dev, err, fmt, ap);
360 	va_end(ap);
361 
362 	if (!depth)
363 		__xenbus_switch_state(dev, XenbusStateClosing, 1);
364 }
365 
366 /**
367  * xenbus_grant_ring
368  * @dev: xenbus device
369  * @vaddr: starting virtual address of the ring
370  * @nr_pages: number of pages to be granted
371  * @grefs: grant reference array to be filled in
372  *
373  * Grant access to the given @vaddr to the peer of the given device.
374  * Then fill in @grefs with grant references.  Return 0 on success, or
375  * -errno on error.  On error, the device will switch to
376  * XenbusStateClosing, and the error will be saved in the store.
377  */
378 int xenbus_grant_ring(struct xenbus_device *dev, void *vaddr,
379 		      unsigned int nr_pages, grant_ref_t *grefs)
380 {
381 	int err;
382 	unsigned int i;
383 	grant_ref_t gref_head;
384 
385 	err = gnttab_alloc_grant_references(nr_pages, &gref_head);
386 	if (err) {
387 		xenbus_dev_fatal(dev, err, "granting access to ring page");
388 		return err;
389 	}
390 
391 	for (i = 0; i < nr_pages; i++) {
392 		unsigned long gfn;
393 
394 		if (is_vmalloc_addr(vaddr))
395 			gfn = pfn_to_gfn(vmalloc_to_pfn(vaddr));
396 		else
397 			gfn = virt_to_gfn(vaddr);
398 
399 		grefs[i] = gnttab_claim_grant_reference(&gref_head);
400 		gnttab_grant_foreign_access_ref(grefs[i], dev->otherend_id,
401 						gfn, 0);
402 
403 		vaddr = vaddr + XEN_PAGE_SIZE;
404 	}
405 
406 	return 0;
407 }
408 EXPORT_SYMBOL_GPL(xenbus_grant_ring);
409 
410 
411 /**
412  * Allocate an event channel for the given xenbus_device, assigning the newly
413  * created local port to *port.  Return 0 on success, or -errno on error.  On
414  * error, the device will switch to XenbusStateClosing, and the error will be
415  * saved in the store.
416  */
417 int xenbus_alloc_evtchn(struct xenbus_device *dev, evtchn_port_t *port)
418 {
419 	struct evtchn_alloc_unbound alloc_unbound;
420 	int err;
421 
422 	alloc_unbound.dom = DOMID_SELF;
423 	alloc_unbound.remote_dom = dev->otherend_id;
424 
425 	err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
426 					  &alloc_unbound);
427 	if (err)
428 		xenbus_dev_fatal(dev, err, "allocating event channel");
429 	else
430 		*port = alloc_unbound.port;
431 
432 	return err;
433 }
434 EXPORT_SYMBOL_GPL(xenbus_alloc_evtchn);
435 
436 
437 /**
438  * Free an existing event channel. Returns 0 on success or -errno on error.
439  */
440 int xenbus_free_evtchn(struct xenbus_device *dev, evtchn_port_t port)
441 {
442 	struct evtchn_close close;
443 	int err;
444 
445 	close.port = port;
446 
447 	err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
448 	if (err)
449 		xenbus_dev_error(dev, err, "freeing event channel %u", port);
450 
451 	return err;
452 }
453 EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
454 
455 
456 /**
457  * xenbus_map_ring_valloc
458  * @dev: xenbus device
459  * @gnt_refs: grant reference array
460  * @nr_grefs: number of grant references
461  * @vaddr: pointer to address to be filled out by mapping
462  *
463  * Map @nr_grefs pages of memory into this domain from another
464  * domain's grant table.  xenbus_map_ring_valloc allocates @nr_grefs
465  * pages of virtual address space, maps the pages to that address, and
466  * sets *vaddr to that address.  Returns 0 on success, and -errno on
467  * error. If an error is returned, device will switch to
468  * XenbusStateClosing and the error message will be saved in XenStore.
469  */
470 int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs,
471 			   unsigned int nr_grefs, void **vaddr)
472 {
473 	int err;
474 	struct map_ring_valloc *info;
475 
476 	*vaddr = NULL;
477 
478 	if (nr_grefs > XENBUS_MAX_RING_GRANTS)
479 		return -EINVAL;
480 
481 	info = kzalloc(sizeof(*info), GFP_KERNEL);
482 	if (!info)
483 		return -ENOMEM;
484 
485 	info->node = kzalloc(sizeof(*info->node), GFP_KERNEL);
486 	if (!info->node)
487 		err = -ENOMEM;
488 	else
489 		err = ring_ops->map(dev, info, gnt_refs, nr_grefs, vaddr);
490 
491 	kfree(info->node);
492 	kfree(info);
493 	return err;
494 }
495 EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
496 
497 /* N.B. sizeof(phys_addr_t) doesn't always equal to sizeof(unsigned
498  * long), e.g. 32-on-64.  Caller is responsible for preparing the
499  * right array to feed into this function */
500 static int __xenbus_map_ring(struct xenbus_device *dev,
501 			     grant_ref_t *gnt_refs,
502 			     unsigned int nr_grefs,
503 			     grant_handle_t *handles,
504 			     struct map_ring_valloc *info,
505 			     unsigned int flags,
506 			     bool *leaked)
507 {
508 	int i, j;
509 
510 	if (nr_grefs > XENBUS_MAX_RING_GRANTS)
511 		return -EINVAL;
512 
513 	for (i = 0; i < nr_grefs; i++) {
514 		gnttab_set_map_op(&info->map[i], info->phys_addrs[i], flags,
515 				  gnt_refs[i], dev->otherend_id);
516 		handles[i] = INVALID_GRANT_HANDLE;
517 	}
518 
519 	gnttab_batch_map(info->map, i);
520 
521 	for (i = 0; i < nr_grefs; i++) {
522 		if (info->map[i].status != GNTST_okay) {
523 			xenbus_dev_fatal(dev, info->map[i].status,
524 					 "mapping in shared page %d from domain %d",
525 					 gnt_refs[i], dev->otherend_id);
526 			goto fail;
527 		} else
528 			handles[i] = info->map[i].handle;
529 	}
530 
531 	return 0;
532 
533  fail:
534 	for (i = j = 0; i < nr_grefs; i++) {
535 		if (handles[i] != INVALID_GRANT_HANDLE) {
536 			gnttab_set_unmap_op(&info->unmap[j],
537 					    info->phys_addrs[i],
538 					    GNTMAP_host_map, handles[i]);
539 			j++;
540 		}
541 	}
542 
543 	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, info->unmap, j));
544 
545 	*leaked = false;
546 	for (i = 0; i < j; i++) {
547 		if (info->unmap[i].status != GNTST_okay) {
548 			*leaked = true;
549 			break;
550 		}
551 	}
552 
553 	return -ENOENT;
554 }
555 
556 /**
557  * xenbus_unmap_ring
558  * @dev: xenbus device
559  * @handles: grant handle array
560  * @nr_handles: number of handles in the array
561  * @vaddrs: addresses to unmap
562  *
563  * Unmap memory in this domain that was imported from another domain.
564  * Returns 0 on success and returns GNTST_* on error
565  * (see xen/include/interface/grant_table.h).
566  */
567 static int xenbus_unmap_ring(struct xenbus_device *dev, grant_handle_t *handles,
568 			     unsigned int nr_handles, unsigned long *vaddrs)
569 {
570 	struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
571 	int i;
572 	int err;
573 
574 	if (nr_handles > XENBUS_MAX_RING_GRANTS)
575 		return -EINVAL;
576 
577 	for (i = 0; i < nr_handles; i++)
578 		gnttab_set_unmap_op(&unmap[i], vaddrs[i],
579 				    GNTMAP_host_map, handles[i]);
580 
581 	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i));
582 
583 	err = GNTST_okay;
584 	for (i = 0; i < nr_handles; i++) {
585 		if (unmap[i].status != GNTST_okay) {
586 			xenbus_dev_error(dev, unmap[i].status,
587 					 "unmapping page at handle %d error %d",
588 					 handles[i], unmap[i].status);
589 			err = unmap[i].status;
590 			break;
591 		}
592 	}
593 
594 	return err;
595 }
596 
597 static void xenbus_map_ring_setup_grant_hvm(unsigned long gfn,
598 					    unsigned int goffset,
599 					    unsigned int len,
600 					    void *data)
601 {
602 	struct map_ring_valloc *info = data;
603 	unsigned long vaddr = (unsigned long)gfn_to_virt(gfn);
604 
605 	info->phys_addrs[info->idx] = vaddr;
606 	info->addrs[info->idx] = vaddr;
607 
608 	info->idx++;
609 }
610 
611 static int xenbus_map_ring_hvm(struct xenbus_device *dev,
612 			       struct map_ring_valloc *info,
613 			       grant_ref_t *gnt_ref,
614 			       unsigned int nr_grefs,
615 			       void **vaddr)
616 {
617 	struct xenbus_map_node *node = info->node;
618 	int err;
619 	void *addr;
620 	bool leaked = false;
621 	unsigned int nr_pages = XENBUS_PAGES(nr_grefs);
622 
623 	err = xen_alloc_unpopulated_pages(nr_pages, node->hvm.pages);
624 	if (err)
625 		goto out_err;
626 
627 	gnttab_foreach_grant(node->hvm.pages, nr_grefs,
628 			     xenbus_map_ring_setup_grant_hvm,
629 			     info);
630 
631 	err = __xenbus_map_ring(dev, gnt_ref, nr_grefs, node->handles,
632 				info, GNTMAP_host_map, &leaked);
633 	node->nr_handles = nr_grefs;
634 
635 	if (err)
636 		goto out_free_ballooned_pages;
637 
638 	addr = vmap(node->hvm.pages, nr_pages, VM_MAP | VM_IOREMAP,
639 		    PAGE_KERNEL);
640 	if (!addr) {
641 		err = -ENOMEM;
642 		goto out_xenbus_unmap_ring;
643 	}
644 
645 	node->hvm.addr = addr;
646 
647 	spin_lock(&xenbus_valloc_lock);
648 	list_add(&node->next, &xenbus_valloc_pages);
649 	spin_unlock(&xenbus_valloc_lock);
650 
651 	*vaddr = addr;
652 	info->node = NULL;
653 
654 	return 0;
655 
656  out_xenbus_unmap_ring:
657 	if (!leaked)
658 		xenbus_unmap_ring(dev, node->handles, nr_grefs, info->addrs);
659 	else
660 		pr_alert("leaking %p size %u page(s)",
661 			 addr, nr_pages);
662  out_free_ballooned_pages:
663 	if (!leaked)
664 		xen_free_unpopulated_pages(nr_pages, node->hvm.pages);
665  out_err:
666 	return err;
667 }
668 
669 /**
670  * xenbus_unmap_ring_vfree
671  * @dev: xenbus device
672  * @vaddr: addr to unmap
673  *
674  * Based on Rusty Russell's skeleton driver's unmap_page.
675  * Unmap a page of memory in this domain that was imported from another domain.
676  * Use xenbus_unmap_ring_vfree if you mapped in your memory with
677  * xenbus_map_ring_valloc (it will free the virtual address space).
678  * Returns 0 on success and returns GNTST_* on error
679  * (see xen/include/interface/grant_table.h).
680  */
681 int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
682 {
683 	return ring_ops->unmap(dev, vaddr);
684 }
685 EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
686 
687 #ifdef CONFIG_XEN_PV
688 static int map_ring_apply(pte_t *pte, unsigned long addr, void *data)
689 {
690 	struct map_ring_valloc *info = data;
691 
692 	info->phys_addrs[info->idx++] = arbitrary_virt_to_machine(pte).maddr;
693 	return 0;
694 }
695 
696 static int xenbus_map_ring_pv(struct xenbus_device *dev,
697 			      struct map_ring_valloc *info,
698 			      grant_ref_t *gnt_refs,
699 			      unsigned int nr_grefs,
700 			      void **vaddr)
701 {
702 	struct xenbus_map_node *node = info->node;
703 	struct vm_struct *area;
704 	bool leaked = false;
705 	int err = -ENOMEM;
706 
707 	area = get_vm_area(XEN_PAGE_SIZE * nr_grefs, VM_IOREMAP);
708 	if (!area)
709 		return -ENOMEM;
710 	if (apply_to_page_range(&init_mm, (unsigned long)area->addr,
711 				XEN_PAGE_SIZE * nr_grefs, map_ring_apply, info))
712 		goto failed;
713 	err = __xenbus_map_ring(dev, gnt_refs, nr_grefs, node->handles,
714 				info, GNTMAP_host_map | GNTMAP_contains_pte,
715 				&leaked);
716 	if (err)
717 		goto failed;
718 
719 	node->nr_handles = nr_grefs;
720 	node->pv.area = area;
721 
722 	spin_lock(&xenbus_valloc_lock);
723 	list_add(&node->next, &xenbus_valloc_pages);
724 	spin_unlock(&xenbus_valloc_lock);
725 
726 	*vaddr = area->addr;
727 	info->node = NULL;
728 
729 	return 0;
730 
731 failed:
732 	if (!leaked)
733 		free_vm_area(area);
734 	else
735 		pr_alert("leaking VM area %p size %u page(s)", area, nr_grefs);
736 
737 	return err;
738 }
739 
740 static int xenbus_unmap_ring_pv(struct xenbus_device *dev, void *vaddr)
741 {
742 	struct xenbus_map_node *node;
743 	struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
744 	unsigned int level;
745 	int i;
746 	bool leaked = false;
747 	int err;
748 
749 	spin_lock(&xenbus_valloc_lock);
750 	list_for_each_entry(node, &xenbus_valloc_pages, next) {
751 		if (node->pv.area->addr == vaddr) {
752 			list_del(&node->next);
753 			goto found;
754 		}
755 	}
756 	node = NULL;
757  found:
758 	spin_unlock(&xenbus_valloc_lock);
759 
760 	if (!node) {
761 		xenbus_dev_error(dev, -ENOENT,
762 				 "can't find mapped virtual address %p", vaddr);
763 		return GNTST_bad_virt_addr;
764 	}
765 
766 	for (i = 0; i < node->nr_handles; i++) {
767 		unsigned long addr;
768 
769 		memset(&unmap[i], 0, sizeof(unmap[i]));
770 		addr = (unsigned long)vaddr + (XEN_PAGE_SIZE * i);
771 		unmap[i].host_addr = arbitrary_virt_to_machine(
772 			lookup_address(addr, &level)).maddr;
773 		unmap[i].dev_bus_addr = 0;
774 		unmap[i].handle = node->handles[i];
775 	}
776 
777 	BUG_ON(HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i));
778 
779 	err = GNTST_okay;
780 	leaked = false;
781 	for (i = 0; i < node->nr_handles; i++) {
782 		if (unmap[i].status != GNTST_okay) {
783 			leaked = true;
784 			xenbus_dev_error(dev, unmap[i].status,
785 					 "unmapping page at handle %d error %d",
786 					 node->handles[i], unmap[i].status);
787 			err = unmap[i].status;
788 			break;
789 		}
790 	}
791 
792 	if (!leaked)
793 		free_vm_area(node->pv.area);
794 	else
795 		pr_alert("leaking VM area %p size %u page(s)",
796 			 node->pv.area, node->nr_handles);
797 
798 	kfree(node);
799 	return err;
800 }
801 
802 static const struct xenbus_ring_ops ring_ops_pv = {
803 	.map = xenbus_map_ring_pv,
804 	.unmap = xenbus_unmap_ring_pv,
805 };
806 #endif
807 
808 struct unmap_ring_hvm
809 {
810 	unsigned int idx;
811 	unsigned long addrs[XENBUS_MAX_RING_GRANTS];
812 };
813 
814 static void xenbus_unmap_ring_setup_grant_hvm(unsigned long gfn,
815 					      unsigned int goffset,
816 					      unsigned int len,
817 					      void *data)
818 {
819 	struct unmap_ring_hvm *info = data;
820 
821 	info->addrs[info->idx] = (unsigned long)gfn_to_virt(gfn);
822 
823 	info->idx++;
824 }
825 
826 static int xenbus_unmap_ring_hvm(struct xenbus_device *dev, void *vaddr)
827 {
828 	int rv;
829 	struct xenbus_map_node *node;
830 	void *addr;
831 	struct unmap_ring_hvm info = {
832 		.idx = 0,
833 	};
834 	unsigned int nr_pages;
835 
836 	spin_lock(&xenbus_valloc_lock);
837 	list_for_each_entry(node, &xenbus_valloc_pages, next) {
838 		addr = node->hvm.addr;
839 		if (addr == vaddr) {
840 			list_del(&node->next);
841 			goto found;
842 		}
843 	}
844 	node = addr = NULL;
845  found:
846 	spin_unlock(&xenbus_valloc_lock);
847 
848 	if (!node) {
849 		xenbus_dev_error(dev, -ENOENT,
850 				 "can't find mapped virtual address %p", vaddr);
851 		return GNTST_bad_virt_addr;
852 	}
853 
854 	nr_pages = XENBUS_PAGES(node->nr_handles);
855 
856 	gnttab_foreach_grant(node->hvm.pages, node->nr_handles,
857 			     xenbus_unmap_ring_setup_grant_hvm,
858 			     &info);
859 
860 	rv = xenbus_unmap_ring(dev, node->handles, node->nr_handles,
861 			       info.addrs);
862 	if (!rv) {
863 		vunmap(vaddr);
864 		xen_free_unpopulated_pages(nr_pages, node->hvm.pages);
865 	}
866 	else
867 		WARN(1, "Leaking %p, size %u page(s)\n", vaddr, nr_pages);
868 
869 	kfree(node);
870 	return rv;
871 }
872 
873 /**
874  * xenbus_read_driver_state
875  * @path: path for driver
876  *
877  * Return the state of the driver rooted at the given store path, or
878  * XenbusStateUnknown if no state can be read.
879  */
880 enum xenbus_state xenbus_read_driver_state(const char *path)
881 {
882 	enum xenbus_state result;
883 	int err = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
884 	if (err)
885 		result = XenbusStateUnknown;
886 
887 	return result;
888 }
889 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);
890 
891 static const struct xenbus_ring_ops ring_ops_hvm = {
892 	.map = xenbus_map_ring_hvm,
893 	.unmap = xenbus_unmap_ring_hvm,
894 };
895 
896 void __init xenbus_ring_ops_init(void)
897 {
898 #ifdef CONFIG_XEN_PV
899 	if (!xen_feature(XENFEAT_auto_translated_physmap))
900 		ring_ops = &ring_ops_pv;
901 	else
902 #endif
903 		ring_ops = &ring_ops_hvm;
904 }
905