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