sys/xen/xenbus/xenbus.c

   1 /******************************************************************************
   2  * Copyright (C) 2005 XenSource Ltd
   3  *
   4  * This file may be distributed separately from the Linux kernel, or
   5  * incorporated into other software packages, subject to the following license:
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this source file (the "Software"), to deal in the Software without
   9  * restriction, including without limitation the rights to use, copy, modify,
  10  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  11  * and to permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  23  * IN THE SOFTWARE.
  24  */
  25
  26 /**
  27  * \file xenbus.c
  28  *
  29  * \brief Client-facing interface for the Xenbus driver.
  30  *
  31  * In other words, the interface between the Xenbus and the device-specific
  32  * code, be it the frontend or the backend of that driver.
  33  */
  34
  35 #if 0
  36 #define DPRINTK(fmt, args...) \
  37     printk("xenbus_client (%s:%d) " fmt ".\n", __FUNCTION__, __LINE__, ##args)
  38 #else
  39 #define DPRINTK(fmt, args...) ((void)0)
  40 #endif
  41
  42 #include <sys/cdefs.h>
  43 __FBSDID("$FreeBSD$");
  44
  45 #include <sys/cdefs.h>
  46 #include <sys/param.h>
  47 #include <sys/kernel.h>
  48 #include <sys/types.h>
  49 #include <sys/malloc.h>
  50 #include <sys/libkern.h>
  51 #include <sys/sbuf.h>
  52
  53 #include <machine/xen/xen-os.h>
  54 #include <xen/hypervisor.h>
  55 #include <xen/evtchn.h>
  56 #include <xen/gnttab.h>
  57 #include <xen/xenbus/xenbusvar.h>
  58 #include <machine/stdarg.h>
  59
  60 MALLOC_DEFINE(M_XENBUS, "xenbus", "XenBus Support");
  61
  62 /*------------------------- Private Functions --------------------------------*/
  63 /**
  64  * \brief Construct the error path corresponding to the given XenBus
  65  *        device.
  66  *
  67  * \param dev  The XenBus device for which we are constructing an error path.
  68  *
  69  * \return  On success, the contructed error path.  Otherwise NULL.
  70  *
  71  * It is the caller's responsibility to free any returned error path
  72  * node using the M_XENBUS malloc type.
  73  */
  74 static char *
  75 error_path(device_t dev)
  76 {
  77         char *path_buffer = malloc(strlen("error/")
  78             + strlen(xenbus_get_node(dev)) + 1,M_XENBUS, M_WAITOK);
  79
  80         strcpy(path_buffer, "error/");
  81         strcpy(path_buffer + strlen("error/"), xenbus_get_node(dev));
  82
  83         return (path_buffer);
  84 }
  85
  86 /*--------------------------- Public Functions -------------------------------*/
  87 /*-------- API comments for these methods can be found in xenbusvar.h --------*/
  88 const char *
  89 xenbus_strstate(XenbusState state)
  90 {
  91         static const char *const name[] = {
  92                 [ XenbusStateUnknown      ] = "Unknown",
  93                 [ XenbusStateInitialising ] = "Initialising",
  94                 [ XenbusStateInitWait     ] = "InitWait",
  95                 [ XenbusStateInitialised  ] = "Initialised",
  96                 [ XenbusStateConnected    ] = "Connected",
  97                 [ XenbusStateClosing      ] = "Closing",
  98                 [ XenbusStateClosed       ] = "Closed",
  99         };
 100
 101         return ((state < (XenbusStateClosed + 1)) ? name[state] : "INVALID");
 102 }
 103
 104 int
 105 xenbus_watch_path(device_t dev, char *path, struct xs_watch *watch,
 106     xs_watch_cb_t *callback)
 107 {
 108         int error;
 109
 110         watch->node = path;
 111         watch->callback = callback;
 112
 113         error = xs_register_watch(watch);
 114
 115         if (error) {
 116                 watch->node = NULL;
 117                 watch->callback = NULL;
 118                 xenbus_dev_fatal(dev, error, "adding watch on %s", path);
 119         }
 120
 121         return (error);
 122 }
 123
 124 int
 125 xenbus_watch_path2(device_t dev, const char *path,
 126     const char *path2, struct xs_watch *watch,
 127     xs_watch_cb_t *callback)
 128 {
 129         int error;
 130         char *state = malloc(strlen(path) + 1 + strlen(path2) + 1,
 131            M_XENBUS, M_WAITOK);
 132
 133         strcpy(state, path);
 134         strcat(state, "/");
 135         strcat(state, path2);
 136
 137         error = xenbus_watch_path(dev, state, watch, callback);
 138         if (error) {
 139                 free(state,M_XENBUS);
 140         }
 141
 142         return (error);
 143 }
 144
 145 void
 146 xenbus_dev_verror(device_t dev, int err, const char *fmt, va_list ap)
 147 {
 148         int ret;
 149         unsigned int len;
 150         char *printf_buffer = NULL, *path_buffer = NULL;
 151
 152 #define PRINTF_BUFFER_SIZE 4096
 153         printf_buffer = malloc(PRINTF_BUFFER_SIZE,M_XENBUS, M_WAITOK);
 154
 155         len = sprintf(printf_buffer, "%i ", err);
 156         ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
 157
 158         KASSERT(len + ret <= PRINTF_BUFFER_SIZE-1, ("xenbus error message too big"));
 159         device_printf(dev, "Error %s\n", printf_buffer);
 160         path_buffer = error_path(dev);
 161
 162         if (path_buffer == NULL) {
 163                 printf("xenbus: failed to write error node for %s (%s)\n",
 164                        xenbus_get_node(dev), printf_buffer);
 165                 goto fail;
 166         }
 167
 168         if (xs_write(XST_NIL, path_buffer, "error", printf_buffer) != 0) {
 169                 printf("xenbus: failed to write error node for %s (%s)\n",
 170                        xenbus_get_node(dev), printf_buffer);
 171                 goto fail;
 172         }
 173
 174  fail:
 175         if (printf_buffer)
 176                 free(printf_buffer,M_XENBUS);
 177         if (path_buffer)
 178                 free(path_buffer,M_XENBUS);
 179 }
 180
 181 void
 182 xenbus_dev_error(device_t dev, int err, const char *fmt, ...)
 183 {
 184         va_list ap;
 185
 186         va_start(ap, fmt);
 187         xenbus_dev_verror(dev, err, fmt, ap);
 188         va_end(ap);
 189 }
 190
 191 void
 192 xenbus_dev_vfatal(device_t dev, int err, const char *fmt, va_list ap)
 193 {
 194         xenbus_dev_verror(dev, err, fmt, ap);
 195         device_printf(dev, "Fatal error. Transitioning to Closing State\n");
 196         xenbus_set_state(dev, XenbusStateClosing);
 197 }
 198
 199 void
 200 xenbus_dev_fatal(device_t dev, int err, const char *fmt, ...)
 201 {
 202         va_list ap;
 203
 204         va_start(ap, fmt);
 205         xenbus_dev_vfatal(dev, err, fmt, ap);
 206         va_end(ap);
 207 }
 208
 209 int
 210 xenbus_grant_ring(device_t dev, unsigned long ring_mfn, grant_ref_t *refp)
 211 {
 212         int error;
 213
 214         error = gnttab_grant_foreign_access(
 215                 xenbus_get_otherend_id(dev), ring_mfn, 0, refp);
 216         if (error) {
 217                 xenbus_dev_fatal(dev, error, "granting access to ring page");
 218                 return (error);
 219         }
 220
 221         return (0);
 222 }
 223
 224 int
 225 xenbus_alloc_evtchn(device_t dev, evtchn_port_t *port)
 226 {
 227         struct evtchn_alloc_unbound alloc_unbound;
 228         int err;
 229
 230         alloc_unbound.dom        = DOMID_SELF;
 231         alloc_unbound.remote_dom = xenbus_get_otherend_id(dev);
 232
 233         err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
 234                                           &alloc_unbound);
 235
 236         if (err) {
 237                 xenbus_dev_fatal(dev, -err, "allocating event channel");
 238                 return (-err);
 239         }
 240         *port = alloc_unbound.port;
 241         return (0);
 242 }
 243
 244 int
 245 xenbus_free_evtchn(device_t dev, evtchn_port_t port)
 246 {
 247         struct evtchn_close close;
 248         int err;
 249
 250         close.port = port;
 251
 252         err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
 253         if (err) {
 254                 xenbus_dev_error(dev, -err, "freeing event channel %d", port);
 255                 return (-err);
 256         }
 257         return (0);
 258 }
 259
 260 XenbusState
 261 xenbus_read_driver_state(const char *path)
 262 {
 263         XenbusState result;
 264         int error;
 265
 266         error = xs_gather(XST_NIL, path, "state", "%d", &result, NULL);
 267         if (error)
 268                 result = XenbusStateClosed;
 269
 270         return (result);
 271 }
 272
 273 int
 274 xenbus_dev_is_online(device_t dev)
 275 {
 276         const char *path;
 277         int error;
 278         int value;
 279
 280         path = xenbus_get_node(dev);
 281         error = xs_gather(XST_NIL, path, "online", "%d", &value, NULL);
 282         if (error != 0) {
 283                 /* Default to not online. */
 284                 value = 0;
 285         }
 286
 287         return (value);
 288 }