xen: replace callers of alloc_vm_area()/free_vm_area() with xen_ prefixed one
[linux-2.6.git] / drivers / xen / xenbus / xenbus_client.c
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/types.h>
34 #include <linux/vmalloc.h>
35 #include <asm/xen/hypervisor.h>
36 #include <xen/interface/xen.h>
37 #include <xen/interface/event_channel.h>
38 #include <xen/events.h>
39 #include <xen/grant_table.h>
40 #include <xen/xenbus.h>
41
42 const char *xenbus_strstate(enum xenbus_state state)
43 {
44         static const char *const name[] = {
45                 [ XenbusStateUnknown      ] = "Unknown",
46                 [ XenbusStateInitialising ] = "Initialising",
47                 [ XenbusStateInitWait     ] = "InitWait",
48                 [ XenbusStateInitialised  ] = "Initialised",
49                 [ XenbusStateConnected    ] = "Connected",
50                 [ XenbusStateClosing      ] = "Closing",
51                 [ XenbusStateClosed       ] = "Closed",
52         };
53         return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
54 }
55 EXPORT_SYMBOL_GPL(xenbus_strstate);
56
57 /**
58  * xenbus_watch_path - register a watch
59  * @dev: xenbus device
60  * @path: path to watch
61  * @watch: watch to register
62  * @callback: callback to register
63  *
64  * Register a @watch on the given path, using the given xenbus_watch structure
65  * for storage, and the given @callback function as the callback.  Return 0 on
66  * success, or -errno on error.  On success, the given @path will be saved as
67  * @watch->node, and remains the caller's to free.  On error, @watch->node will
68  * be NULL, the device will switch to %XenbusStateClosing, and the error will
69  * be saved in the store.
70  */
71 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
72                       struct xenbus_watch *watch,
73                       void (*callback)(struct xenbus_watch *,
74                                        const char **, unsigned int))
75 {
76         int err;
77
78         watch->node = path;
79         watch->callback = callback;
80
81         err = register_xenbus_watch(watch);
82
83         if (err) {
84                 watch->node = NULL;
85                 watch->callback = NULL;
86                 xenbus_dev_fatal(dev, err, "adding watch on %s", path);
87         }
88
89         return err;
90 }
91 EXPORT_SYMBOL_GPL(xenbus_watch_path);
92
93
94 /**
95  * xenbus_watch_pathfmt - register a watch on a sprintf-formatted path
96  * @dev: xenbus device
97  * @watch: watch to register
98  * @callback: callback to register
99  * @pathfmt: format of path to watch
100  *
101  * Register a watch on the given @path, using the given xenbus_watch
102  * structure for storage, and the given @callback function as the callback.
103  * Return 0 on success, or -errno on error.  On success, the watched path
104  * (@path/@path2) will be saved as @watch->node, and becomes the caller's to
105  * kfree().  On error, watch->node will be NULL, so the caller has nothing to
106  * free, the device will switch to %XenbusStateClosing, and the error will be
107  * saved in the store.
108  */
109 int xenbus_watch_pathfmt(struct xenbus_device *dev,
110                          struct xenbus_watch *watch,
111                          void (*callback)(struct xenbus_watch *,
112                                         const char **, unsigned int),
113                          const char *pathfmt, ...)
114 {
115         int err;
116         va_list ap;
117         char *path;
118
119         va_start(ap, pathfmt);
120         path = kvasprintf(GFP_KERNEL, pathfmt, ap);
121         va_end(ap);
122
123         if (!path) {
124                 xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
125                 return -ENOMEM;
126         }
127         err = xenbus_watch_path(dev, path, watch, callback);
128
129         if (err)
130                 kfree(path);
131         return err;
132 }
133 EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
134
135
136 /**
137  * xenbus_switch_state
138  * @dev: xenbus device
139  * @xbt: transaction handle
140  * @state: new state
141  *
142  * Advertise in the store a change of the given driver to the given new_state.
143  * Return 0 on success, or -errno on error.  On error, the device will switch
144  * to XenbusStateClosing, and the error will be saved in the store.
145  */
146 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
147 {
148         /* We check whether the state is currently set to the given value, and
149            if not, then the state is set.  We don't want to unconditionally
150            write the given state, because we don't want to fire watches
151            unnecessarily.  Furthermore, if the node has gone, we don't write
152            to it, as the device will be tearing down, and we don't want to
153            resurrect that directory.
154
155            Note that, because of this cached value of our state, this function
156            will not work inside a Xenstore transaction (something it was
157            trying to in the past) because dev->state would not get reset if
158            the transaction was aborted.
159
160          */
161
162         int current_state;
163         int err;
164
165         if (state == dev->state)
166                 return 0;
167
168         err = xenbus_scanf(XBT_NIL, dev->nodename, "state", "%d",
169                            &current_state);
170         if (err != 1)
171                 return 0;
172
173         err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%d", state);
174         if (err) {
175                 if (state != XenbusStateClosing) /* Avoid looping */
176                         xenbus_dev_fatal(dev, err, "writing new state");
177                 return err;
178         }
179
180         dev->state = state;
181
182         return 0;
183 }
184 EXPORT_SYMBOL_GPL(xenbus_switch_state);
185
186 int xenbus_frontend_closed(struct xenbus_device *dev)
187 {
188         xenbus_switch_state(dev, XenbusStateClosed);
189         complete(&dev->down);
190         return 0;
191 }
192 EXPORT_SYMBOL_GPL(xenbus_frontend_closed);
193
194 /**
195  * Return the path to the error node for the given device, or NULL on failure.
196  * If the value returned is non-NULL, then it is the caller's to kfree.
197  */
198 static char *error_path(struct xenbus_device *dev)
199 {
200         return kasprintf(GFP_KERNEL, "error/%s", dev->nodename);
201 }
202
203
204 static void xenbus_va_dev_error(struct xenbus_device *dev, int err,
205                                 const char *fmt, va_list ap)
206 {
207         int ret;
208         unsigned int len;
209         char *printf_buffer = NULL;
210         char *path_buffer = NULL;
211
212 #define PRINTF_BUFFER_SIZE 4096
213         printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
214         if (printf_buffer == NULL)
215                 goto fail;
216
217         len = sprintf(printf_buffer, "%i ", -err);
218         ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
219
220         BUG_ON(len + ret > PRINTF_BUFFER_SIZE-1);
221
222         dev_err(&dev->dev, "%s\n", printf_buffer);
223
224         path_buffer = error_path(dev);
225
226         if (path_buffer == NULL) {
227                 dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
228                        dev->nodename, printf_buffer);
229                 goto fail;
230         }
231
232         if (xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer) != 0) {
233                 dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
234                        dev->nodename, printf_buffer);
235                 goto fail;
236         }
237
238 fail:
239         kfree(printf_buffer);
240         kfree(path_buffer);
241 }
242
243
244 /**
245  * xenbus_dev_error
246  * @dev: xenbus device
247  * @err: error to report
248  * @fmt: error message format
249  *
250  * Report the given negative errno into the store, along with the given
251  * formatted message.
252  */
253 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...)
254 {
255         va_list ap;
256
257         va_start(ap, fmt);
258         xenbus_va_dev_error(dev, err, fmt, ap);
259         va_end(ap);
260 }
261 EXPORT_SYMBOL_GPL(xenbus_dev_error);
262
263 /**
264  * xenbus_dev_fatal
265  * @dev: xenbus device
266  * @err: error to report
267  * @fmt: error message format
268  *
269  * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
270  * xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly
271  * closedown of this driver and its peer.
272  */
273
274 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...)
275 {
276         va_list ap;
277
278         va_start(ap, fmt);
279         xenbus_va_dev_error(dev, err, fmt, ap);
280         va_end(ap);
281
282         xenbus_switch_state(dev, XenbusStateClosing);
283 }
284 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
285
286 /**
287  * xenbus_grant_ring
288  * @dev: xenbus device
289  * @ring_mfn: mfn of ring to grant
290
291  * Grant access to the given @ring_mfn to the peer of the given device.  Return
292  * 0 on success, or -errno on error.  On error, the device will switch to
293  * XenbusStateClosing, and the error will be saved in the store.
294  */
295 int xenbus_grant_ring(struct xenbus_device *dev, unsigned long ring_mfn)
296 {
297         int err = gnttab_grant_foreign_access(dev->otherend_id, ring_mfn, 0);
298         if (err < 0)
299                 xenbus_dev_fatal(dev, err, "granting access to ring page");
300         return err;
301 }
302 EXPORT_SYMBOL_GPL(xenbus_grant_ring);
303
304
305 /**
306  * Allocate an event channel for the given xenbus_device, assigning the newly
307  * created local port to *port.  Return 0 on success, or -errno on error.  On
308  * error, the device will switch to XenbusStateClosing, and the error will be
309  * saved in the store.
310  */
311 int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port)
312 {
313         struct evtchn_alloc_unbound alloc_unbound;
314         int err;
315
316         alloc_unbound.dom = DOMID_SELF;
317         alloc_unbound.remote_dom = dev->otherend_id;
318
319         err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
320                                           &alloc_unbound);
321         if (err)
322                 xenbus_dev_fatal(dev, err, "allocating event channel");
323         else
324                 *port = alloc_unbound.port;
325
326         return err;
327 }
328 EXPORT_SYMBOL_GPL(xenbus_alloc_evtchn);
329
330
331 /**
332  * Bind to an existing interdomain event channel in another domain. Returns 0
333  * on success and stores the local port in *port. On error, returns -errno,
334  * switches the device to XenbusStateClosing, and saves the error in XenStore.
335  */
336 int xenbus_bind_evtchn(struct xenbus_device *dev, int remote_port, int *port)
337 {
338         struct evtchn_bind_interdomain bind_interdomain;
339         int err;
340
341         bind_interdomain.remote_dom = dev->otherend_id;
342         bind_interdomain.remote_port = remote_port;
343
344         err = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
345                                           &bind_interdomain);
346         if (err)
347                 xenbus_dev_fatal(dev, err,
348                                  "binding to event channel %d from domain %d",
349                                  remote_port, dev->otherend_id);
350         else
351                 *port = bind_interdomain.local_port;
352
353         return err;
354 }
355 EXPORT_SYMBOL_GPL(xenbus_bind_evtchn);
356
357
358 /**
359  * Free an existing event channel. Returns 0 on success or -errno on error.
360  */
361 int xenbus_free_evtchn(struct xenbus_device *dev, int port)
362 {
363         struct evtchn_close close;
364         int err;
365
366         close.port = port;
367
368         err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
369         if (err)
370                 xenbus_dev_error(dev, err, "freeing event channel %d", port);
371
372         return err;
373 }
374 EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
375
376
377 /**
378  * xenbus_map_ring_valloc
379  * @dev: xenbus device
380  * @gnt_ref: grant reference
381  * @vaddr: pointer to address to be filled out by mapping
382  *
383  * Based on Rusty Russell's skeleton driver's map_page.
384  * Map a page of memory into this domain from another domain's grant table.
385  * xenbus_map_ring_valloc allocates a page of virtual address space, maps the
386  * page to that address, and sets *vaddr to that address.
387  * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
388  * or -ENOMEM on error. If an error is returned, device will switch to
389  * XenbusStateClosing and the error message will be saved in XenStore.
390  */
391 int xenbus_map_ring_valloc(struct xenbus_device *dev, int gnt_ref, void **vaddr)
392 {
393         struct gnttab_map_grant_ref op = {
394                 .flags = GNTMAP_host_map,
395                 .ref   = gnt_ref,
396                 .dom   = dev->otherend_id,
397         };
398         struct vm_struct *area;
399
400         *vaddr = NULL;
401
402         area = xen_alloc_vm_area(PAGE_SIZE);
403         if (!area)
404                 return -ENOMEM;
405
406         op.host_addr = (unsigned long)area->addr;
407
408         if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
409                 BUG();
410
411         if (op.status != GNTST_okay) {
412                 xen_free_vm_area(area);
413                 xenbus_dev_fatal(dev, op.status,
414                                  "mapping in shared page %d from domain %d",
415                                  gnt_ref, dev->otherend_id);
416                 return op.status;
417         }
418
419         /* Stuff the handle in an unused field */
420         area->phys_addr = (unsigned long)op.handle;
421
422         *vaddr = area->addr;
423         return 0;
424 }
425 EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
426
427
428 /**
429  * xenbus_map_ring
430  * @dev: xenbus device
431  * @gnt_ref: grant reference
432  * @handle: pointer to grant handle to be filled
433  * @vaddr: address to be mapped to
434  *
435  * Map a page of memory into this domain from another domain's grant table.
436  * xenbus_map_ring does not allocate the virtual address space (you must do
437  * this yourself!). It only maps in the page to the specified address.
438  * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
439  * or -ENOMEM on error. If an error is returned, device will switch to
440  * XenbusStateClosing and the error message will be saved in XenStore.
441  */
442 int xenbus_map_ring(struct xenbus_device *dev, int gnt_ref,
443                     grant_handle_t *handle, void *vaddr)
444 {
445         struct gnttab_map_grant_ref op = {
446                 .host_addr = (unsigned long)vaddr,
447                 .flags     = GNTMAP_host_map,
448                 .ref       = gnt_ref,
449                 .dom       = dev->otherend_id,
450         };
451
452         if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
453                 BUG();
454
455         if (op.status != GNTST_okay) {
456                 xenbus_dev_fatal(dev, op.status,
457                                  "mapping in shared page %d from domain %d",
458                                  gnt_ref, dev->otherend_id);
459         } else
460                 *handle = op.handle;
461
462         return op.status;
463 }
464 EXPORT_SYMBOL_GPL(xenbus_map_ring);
465
466
467 /**
468  * xenbus_unmap_ring_vfree
469  * @dev: xenbus device
470  * @vaddr: addr to unmap
471  *
472  * Based on Rusty Russell's skeleton driver's unmap_page.
473  * Unmap a page of memory in this domain that was imported from another domain.
474  * Use xenbus_unmap_ring_vfree if you mapped in your memory with
475  * xenbus_map_ring_valloc (it will free the virtual address space).
476  * Returns 0 on success and returns GNTST_* on error
477  * (see xen/include/interface/grant_table.h).
478  */
479 int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
480 {
481         struct vm_struct *area;
482         struct gnttab_unmap_grant_ref op = {
483                 .host_addr = (unsigned long)vaddr,
484         };
485
486         /* It'd be nice if linux/vmalloc.h provided a find_vm_area(void *addr)
487          * method so that we don't have to muck with vmalloc internals here.
488          * We could force the user to hang on to their struct vm_struct from
489          * xenbus_map_ring_valloc, but these 6 lines considerably simplify
490          * this API.
491          */
492         read_lock(&vmlist_lock);
493         for (area = vmlist; area != NULL; area = area->next) {
494                 if (area->addr == vaddr)
495                         break;
496         }
497         read_unlock(&vmlist_lock);
498
499         if (!area) {
500                 xenbus_dev_error(dev, -ENOENT,
501                                  "can't find mapped virtual address %p", vaddr);
502                 return GNTST_bad_virt_addr;
503         }
504
505         op.handle = (grant_handle_t)area->phys_addr;
506
507         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
508                 BUG();
509
510         if (op.status == GNTST_okay)
511                 xen_free_vm_area(area);
512         else
513                 xenbus_dev_error(dev, op.status,
514                                  "unmapping page at handle %d error %d",
515                                  (int16_t)area->phys_addr, op.status);
516
517         return op.status;
518 }
519 EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
520
521
522 /**
523  * xenbus_unmap_ring
524  * @dev: xenbus device
525  * @handle: grant handle
526  * @vaddr: addr to unmap
527  *
528  * Unmap a page of memory in this domain that was imported from another domain.
529  * Returns 0 on success and returns GNTST_* on error
530  * (see xen/include/interface/grant_table.h).
531  */
532 int xenbus_unmap_ring(struct xenbus_device *dev,
533                       grant_handle_t handle, void *vaddr)
534 {
535         struct gnttab_unmap_grant_ref op = {
536                 .host_addr = (unsigned long)vaddr,
537                 .handle    = handle,
538         };
539
540         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
541                 BUG();
542
543         if (op.status != GNTST_okay)
544                 xenbus_dev_error(dev, op.status,
545                                  "unmapping page at handle %d error %d",
546                                  handle, op.status);
547
548         return op.status;
549 }
550 EXPORT_SYMBOL_GPL(xenbus_unmap_ring);
551
552
553 /**
554  * xenbus_read_driver_state
555  * @path: path for driver
556  *
557  * Return the state of the driver rooted at the given store path, or
558  * XenbusStateUnknown if no state can be read.
559  */
560 enum xenbus_state xenbus_read_driver_state(const char *path)
561 {
562         enum xenbus_state result;
563         int err = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
564         if (err)
565                 result = XenbusStateUnknown;
566
567         return result;
568 }
569 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);