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 <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
  59 #include <machine/stdarg.h>
  60
  61 MALLOC_DEFINE(M_XENBUS, "xenbus", "XenBus Support");
  62
  63 /*------------------------- Private Functions --------------------------------*/
  64 /**
  65  * \brief Construct the error path corresponding to the given XenBus
  66  *        device.
  67  *
  68  * \param dev  The XenBus device for which we are constructing an error path.
  69  *
  70  * \return  On success, the contructed error path.  Otherwise NULL.
  71  *
  72  * It is the caller's responsibility to free any returned error path
  73  * node using the M_XENBUS malloc type.
  74  */
  75 static char *
  76 error_path(device_t dev)
  77 {
  78         char *path_buffer = malloc(strlen("error/")
  79             + strlen(xenbus_get_node(dev)) + 1,M_XENBUS, M_WAITOK);
  80
  81         strcpy(path_buffer, "error/");
  82         strcpy(path_buffer + strlen("error/"), xenbus_get_node(dev));
  83
  84         return (path_buffer);
  85 }
  86
  87 /*--------------------------- Public Functions -------------------------------*/
  88 /*-------- API comments for these methods can be found in xenbusvar.h --------*/
  89 const char *
  90 xenbus_strstate(XenbusState state)
  91 {
  92         static const char *const name[] = {
  93                 [ XenbusStateUnknown      ] = "Unknown",
  94                 [ XenbusStateInitialising ] = "Initialising",
  95                 [ XenbusStateInitWait     ] = "InitWait",
  96                 [ XenbusStateInitialised  ] = "Initialised",
  97                 [ XenbusStateConnected    ] = "Connected",
  98                 [ XenbusStateClosing      ] = "Closing",
  99                 [ XenbusStateClosed       ] = "Closed",
 100         };
 101
 102         return ((state < (XenbusStateClosed + 1)) ? name[state] : "INVALID");
 103 }
 104
 105 int
 106 xenbus_watch_path(device_t dev, char *path, struct xs_watch *watch,
 107     xs_watch_cb_t *callback, uintptr_t callback_data)
 108 {
 109         int error;
 110
 111         watch->node = path;
 112         watch->callback = callback;
 113         watch->callback_data = callback_data;
 114
 115         error = xs_register_watch(watch);
 116
 117         if (error) {
 118                 watch->node = NULL;
 119                 watch->callback = NULL;
 120                 xenbus_dev_fatal(dev, error, "adding watch on %s", path);
 121         }
 122
 123         return (error);
 124 }
 125
 126 int
 127 xenbus_watch_path2(device_t dev, const char *path,
 128     const char *path2, struct xs_watch *watch,
 129     xs_watch_cb_t *callback, uintptr_t callback_data)
 130 {
 131         int error;
 132         char *state = malloc(strlen(path) + 1 + strlen(path2) + 1,
 133            M_XENBUS, M_WAITOK);
 134
 135         strcpy(state, path);
 136         strcat(state, "/");
 137         strcat(state, path2);
 138
 139         error = xenbus_watch_path(dev, state, watch, callback, callback_data);
 140         if (error) {
 141                 free(state,M_XENBUS);
 142         }
 143
 144         return (error);
 145 }
 146
 147 void
 148 xenbus_dev_verror(device_t dev, int err, const char *fmt, va_list ap)
 149 {
 150         int ret;
 151         unsigned int len;
 152         char *printf_buffer = NULL, *path_buffer = NULL;
 153
 154 #define PRINTF_BUFFER_SIZE 4096
 155         printf_buffer = malloc(PRINTF_BUFFER_SIZE,M_XENBUS, M_WAITOK);
 156
 157         len = sprintf(printf_buffer, "%i ", err);
 158         ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
 159
 160         KASSERT(len + ret <= PRINTF_BUFFER_SIZE-1, ("xenbus error message too big"));
 161         device_printf(dev, "Error %s\n", printf_buffer);
 162         path_buffer = error_path(dev);
 163
 164         if (path_buffer == NULL) {
 165                 printf("xenbus: failed to write error node for %s (%s)\n",
 166                        xenbus_get_node(dev), printf_buffer);
 167                 goto fail;
 168         }
 169
 170         if (xs_write(XST_NIL, path_buffer, "error", printf_buffer) != 0) {
 171                 printf("xenbus: failed to write error node for %s (%s)\n",
 172                        xenbus_get_node(dev), printf_buffer);
 173                 goto fail;
 174         }
 175
 176  fail:
 177         if (printf_buffer)
 178                 free(printf_buffer,M_XENBUS);
 179         if (path_buffer)
 180                 free(path_buffer,M_XENBUS);
 181 }
 182
 183 void
 184 xenbus_dev_error(device_t dev, int err, const char *fmt, ...)
 185 {
 186         va_list ap;
 187
 188         va_start(ap, fmt);
 189         xenbus_dev_verror(dev, err, fmt, ap);
 190         va_end(ap);
 191 }
 192
 193 void
 194 xenbus_dev_vfatal(device_t dev, int err, const char *fmt, va_list ap)
 195 {
 196         xenbus_dev_verror(dev, err, fmt, ap);
 197         device_printf(dev, "Fatal error. Transitioning to Closing State\n");
 198         xenbus_set_state(dev, XenbusStateClosing);
 199 }
 200
 201 void
 202 xenbus_dev_fatal(device_t dev, int err, const char *fmt, ...)
 203 {
 204         va_list ap;
 205
 206         va_start(ap, fmt);
 207         xenbus_dev_vfatal(dev, err, fmt, ap);
 208         va_end(ap);
 209 }
 210
 211 int
 212 xenbus_grant_ring(device_t dev, unsigned long ring_mfn, grant_ref_t *refp)
 213 {
 214         int error;
 215
 216         error = gnttab_grant_foreign_access(
 217                 xenbus_get_otherend_id(dev), ring_mfn, 0, refp);
 218         if (error) {
 219                 xenbus_dev_fatal(dev, error, "granting access to ring page");
 220                 return (error);
 221         }
 222
 223         return (0);
 224 }
 225
 226 XenbusState
 227 xenbus_read_driver_state(const char *path)
 228 {
 229         XenbusState result;
 230         int error;
 231
 232         error = xs_gather(XST_NIL, path, "state", "%d", &result, NULL);
 233         if (error)
 234                 result = XenbusStateClosed;
 235
 236         return (result);
 237 }
 238
 239 int
 240 xenbus_dev_is_online(device_t dev)
 241 {
 242         const char *path;
 243         int error;
 244         int value;
 245
 246         path = xenbus_get_node(dev);
 247         error = xs_gather(XST_NIL, path, "online", "%d", &value, NULL);
 248         if (error != 0) {
 249                 /* Default to not online. */
 250                 value = 0;
 251         }
 252
 253         return (value);
 254 }
 255
 256 void
 257 xenbus_localend_changed(device_t dev, const char *path)
 258 {
 259 }