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