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