The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/xen/xenbus/xenbus_client.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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 file may be distributed separately from the Linux kernel, or
    9  * incorporated into other software packages, subject to the following license:
   10  * 
   11  * Permission is hereby granted, free of charge, to any person obtaining a copy
   12  * of this source file (the "Software"), to deal in the Software without
   13  * restriction, including without limitation the rights to use, copy, modify,
   14  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
   15  * and to permit persons to whom the Software is furnished to do so, subject to
   16  * the following conditions:
   17  * 
   18  * The above copyright notice and this permission notice shall be included in
   19  * all copies or substantial portions of the Software.
   20  * 
   21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   26  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   27  * IN THE SOFTWARE.
   28  */
   29 
   30 
   31 #if 0
   32 #define DPRINTK(fmt, args...) \
   33     printk("xenbus_client (%s:%d) " fmt ".\n", __FUNCTION__, __LINE__, ##args)
   34 #else
   35 #define DPRINTK(fmt, args...) ((void)0)
   36 #endif
   37 
   38 #include <sys/cdefs.h>
   39 __FBSDID("$FreeBSD: releng/8.0/sys/xen/xenbus/xenbus_client.c 186557 2008-12-29 06:31:03Z kmacy $");
   40 
   41 #include <sys/cdefs.h>
   42 #include <sys/types.h>
   43 #include <sys/malloc.h>
   44 #include <sys/libkern.h>
   45 
   46 #include <machine/xen/xen-os.h>
   47 #include <xen/hypervisor.h>
   48 #include <xen/evtchn.h>
   49 #include <xen/gnttab.h>
   50 #include <xen/xenbus/xenbusvar.h>
   51 #include <machine/stdarg.h>
   52 
   53 const char *
   54 xenbus_strstate(XenbusState state)
   55 {
   56         static const char *const name[] = {
   57                 [ XenbusStateUnknown      ] = "Unknown",
   58                 [ XenbusStateInitialising ] = "Initialising",
   59                 [ XenbusStateInitWait     ] = "InitWait",
   60                 [ XenbusStateInitialised  ] = "Initialised",
   61                 [ XenbusStateConnected    ] = "Connected",
   62                 [ XenbusStateClosing      ] = "Closing",
   63                 [ XenbusStateClosed       ] = "Closed",
   64         };
   65 
   66         return ((state < (XenbusStateClosed + 1)) ? name[state] : "INVALID");
   67 }
   68 
   69 int 
   70 xenbus_watch_path(device_t dev, char *path, struct xenbus_watch *watch, 
   71     void (*callback)(struct xenbus_watch *, const char **, unsigned int))
   72 {
   73         int error;
   74 
   75         watch->node = path;
   76         watch->callback = callback;
   77 
   78         error = register_xenbus_watch(watch);
   79 
   80         if (error) {
   81                 watch->node = NULL;
   82                 watch->callback = NULL;
   83                 xenbus_dev_fatal(dev, error, "adding watch on %s", path);
   84         }
   85 
   86         return (error);
   87 }
   88 
   89 int
   90 xenbus_watch_path2(device_t dev, const char *path,
   91     const char *path2, struct xenbus_watch *watch, 
   92     void (*callback)(struct xenbus_watch *, const char **, unsigned int))
   93 {
   94         int error;
   95         char *state = malloc(strlen(path) + 1 + strlen(path2) + 1,
   96             M_DEVBUF, M_WAITOK);
   97 
   98         strcpy(state, path);
   99         strcat(state, "/");
  100         strcat(state, path2);
  101 
  102         error = xenbus_watch_path(dev, state, watch, callback);
  103         if (error) {
  104                 free(state, M_DEVBUF);
  105         }
  106 
  107         return (error);
  108 }
  109 
  110 /**
  111  * Return the path to the error node for the given device, or NULL on failure.
  112  * If the value returned is non-NULL, then it is the caller's to kfree.
  113  */
  114 static char *
  115 error_path(device_t dev)
  116 {
  117         char *path_buffer = malloc(strlen("error/")
  118             + strlen(xenbus_get_node(dev)) + 1, M_DEVBUF, M_WAITOK);
  119 
  120         strcpy(path_buffer, "error/");
  121         strcpy(path_buffer + strlen("error/"), xenbus_get_node(dev));
  122 
  123         return (path_buffer);
  124 }
  125 
  126 
  127 static void
  128 _dev_error(device_t dev, int err, const char *fmt, va_list ap)
  129 {
  130         int ret;
  131         unsigned int len;
  132         char *printf_buffer = NULL, *path_buffer = NULL;
  133 
  134 #define PRINTF_BUFFER_SIZE 4096
  135         printf_buffer = malloc(PRINTF_BUFFER_SIZE, M_DEVBUF, M_WAITOK);
  136 
  137         len = sprintf(printf_buffer, "%i ", err);
  138         ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
  139 
  140         KASSERT(len + ret <= PRINTF_BUFFER_SIZE-1, ("xenbus error message too big"));
  141 #if 0   
  142         dev_err(&dev->dev, "%s\n", printf_buffer);
  143 #endif          
  144         path_buffer = error_path(dev);
  145 
  146         if (path_buffer == NULL) {
  147                 printf("xenbus: failed to write error node for %s (%s)\n",
  148                        xenbus_get_node(dev), printf_buffer);
  149                 goto fail;
  150         }
  151 
  152         if (xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer) != 0) {
  153                 printf("xenbus: failed to write error node for %s (%s)\n",
  154                        xenbus_get_node(dev), printf_buffer);
  155                 goto fail;
  156         }
  157 
  158  fail:
  159         if (printf_buffer)
  160                 free(printf_buffer, M_DEVBUF);
  161         if (path_buffer)
  162                 free(path_buffer, M_DEVBUF);
  163 }
  164 
  165 void
  166 xenbus_dev_error(device_t dev, int err, const char *fmt, ...)
  167 {
  168         va_list ap;
  169 
  170         va_start(ap, fmt);
  171         _dev_error(dev, err, fmt, ap);
  172         va_end(ap);
  173 }
  174 
  175 void
  176 xenbus_dev_fatal(device_t dev, int err, const char *fmt, ...)
  177 {
  178         va_list ap;
  179 
  180         va_start(ap, fmt);
  181         _dev_error(dev, err, fmt, ap);
  182         va_end(ap);
  183         
  184         xenbus_set_state(dev, XenbusStateClosing);
  185 }
  186 
  187 int
  188 xenbus_grant_ring(device_t dev, unsigned long ring_mfn, int *refp)
  189 {
  190         int error;
  191         grant_ref_t ref;
  192 
  193         error = gnttab_grant_foreign_access(
  194                 xenbus_get_otherend_id(dev), ring_mfn, 0, &ref);
  195         if (error) {
  196                 xenbus_dev_fatal(dev, error, "granting access to ring page");
  197                 return (error);
  198         }
  199 
  200         *refp = ref;
  201         return (0);
  202 }
  203 
  204 int
  205 xenbus_alloc_evtchn(device_t dev, int *port)
  206 {
  207         struct evtchn_alloc_unbound alloc_unbound;
  208         int err;
  209 
  210         alloc_unbound.dom        = DOMID_SELF;
  211         alloc_unbound.remote_dom = xenbus_get_otherend_id(dev);
  212 
  213         err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
  214                                           &alloc_unbound);
  215 
  216         if (err) {
  217                 xenbus_dev_fatal(dev, -err, "allocating event channel");
  218                 return (-err);
  219         }
  220         *port = alloc_unbound.port;
  221         return (0);
  222 }
  223 
  224 int
  225 xenbus_free_evtchn(device_t dev, int port)
  226 {
  227         struct evtchn_close close;
  228         int err;
  229 
  230         close.port = port;
  231 
  232         err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
  233         if (err) {
  234                 xenbus_dev_error(dev, -err, "freeing event channel %d", port);
  235                 return (-err);
  236         }
  237         return (0);
  238 }
  239 
  240 XenbusState
  241 xenbus_read_driver_state(const char *path)
  242 {
  243         XenbusState result;
  244         int error;
  245 
  246         error = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
  247         if (error)
  248                 result = XenbusStateClosed;
  249 
  250         return (result);
  251 }

Cache object: 0fcef7ad16365335f8f8775b10f39572


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.