usr/src/uts/common/xen/sys/xenbus_impl.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  *
  29  * xenbus.h (renamed to xenbus_impl.h)
  30  *
  31  * Talks to Xen Store to figure out what devices we have.
  32  *
  33  * Copyright (C) 2005 Rusty Russell, IBM Corporation
  34  *
  35  * This file may be distributed separately from the Linux kernel, or
  36  * incorporated into other software packages, subject to the following license:
  37  *
  38  * Permission is hereby granted, free of charge, to any person obtaining a copy
  39  * of this source file (the "Software"), to deal in the Software without
  40  * restriction, including without limitation the rights to use, copy, modify,
  41  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  42  * and to permit persons to whom the Software is furnished to do so, subject to
  43  * the following conditions:
  44  *
  45  * The above copyright notice and this permission notice shall be included in
  46  * all copies or substantial portions of the Software.
  47  *
  48  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  49  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  50  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  51  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  52  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  53  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  54  * IN THE SOFTWARE.
  55  */
  56
  57 #ifndef _SYS_XENBUS_H
  58 #define _SYS_XENBUS_H
  59
  60 #include <sys/mutex.h>
  61 #include <sys/list.h>
  62
  63 #ifdef  __cplusplus
  64 extern "C" {
  65 #endif
  66
  67 #define XBT_NULL 0
  68
  69 typedef uint32_t xenbus_transaction_t;
  70
  71 /* Register callback to watch this node. */
  72 struct xenbus_watch;
  73 typedef void (*xenbus_watch_cb_t)(struct xenbus_watch *,
  74     const char **vec, unsigned int len);
  75 struct xenbus_watch {
  76         list_node_t             list;
  77         const char              *node;  /* path being watched */
  78         xenbus_watch_cb_t       callback;
  79         struct xenbus_device    *dev;
  80 };
  81
  82 /*
  83  * Call this function when xenstore is available, i.e. the daemon is
  84  * connected to the xenbus device.
  85  */
  86 struct xenbus_notify {
  87         list_node_t list;
  88         void (*notify_func) (int);
  89 };
  90
  91 /* A xenbus device. */
  92 struct xenbus_device {
  93         const char *devicetype;
  94         const char *nodename;
  95         const char *otherend;
  96         int otherend_id;
  97         int otherend_state;
  98         struct xenbus_watch otherend_watch;
  99         int has_error;
 100         int frontend;
 101         void (*otherend_changed)(struct xenbus_device *, XenbusState);
 102         void *data;
 103 };
 104
 105 typedef void (*xvdi_xb_watch_cb_t)(dev_info_t *dip, const char *path,
 106     void *arg);
 107
 108 typedef struct xd_xb_watches {
 109         list_node_t             xxw_list;
 110         int                     xxw_ref;
 111         struct xenbus_watch     xxw_watch;
 112         struct xendev_ppd       *xxw_xppd;
 113         xvdi_xb_watch_cb_t      xxw_cb;
 114         void                    *xxw_arg;
 115 } xd_xb_watches_t;
 116
 117 extern char **xenbus_directory(xenbus_transaction_t t, const char *dir,
 118             const char *node, unsigned int *num);
 119 extern int xenbus_read(xenbus_transaction_t t, const char *dir,
 120             const char *node, void **rstr, unsigned int *len);
 121 extern int xenbus_read_str(const char *dir, const char *node, char **rstr);
 122 extern int xenbus_write(xenbus_transaction_t t, const char *dir,
 123             const char *node, const char *string);
 124 extern int xenbus_mkdir(xenbus_transaction_t t, const char *dir,
 125             const char *node);
 126 extern boolean_t xenbus_exists(const char *dir, const char *node);
 127 extern boolean_t xenbus_exists_dir(const char *dir, const char *node);
 128 extern int xenbus_rm(xenbus_transaction_t t, const char *dir,
 129             const char *node);
 130 extern int xenbus_transaction_start(xenbus_transaction_t *t);
 131 extern int xenbus_transaction_end(xenbus_transaction_t t, int abort);
 132
 133 /* Single read and scanf: returns errno or num scanned if > 0. */
 134 extern int xenbus_scanf(xenbus_transaction_t t, const char *dir,
 135             const char *node, const char *fmt, ...);
 136
 137 /* Single printf and write: returns errno or 0. */
 138 extern int xenbus_printf(xenbus_transaction_t t, const char *dir,
 139             const char *node, const char *fmt, ...);
 140
 141 /*
 142  * Generic read function: NULL-terminated triples of name,
 143  * sprintf-style type string, and pointer. Returns 0 or errno.
 144  */
 145 extern int xenbus_gather(xenbus_transaction_t t, const char *dir, ...);
 146
 147 extern int register_xenbus_watch(struct xenbus_watch *watch);
 148 extern void unregister_xenbus_watch(struct xenbus_watch *watch);
 149 extern void reregister_xenbus_watches(void);
 150
 151 /* Called from xen core code. */
 152 extern void xenbus_suspend(void);
 153 extern void xenbus_resume(void);
 154
 155 #define XENBUS_EXIST_ERR(err) ((err) == ENOENT || (err) == ERANGE)
 156
 157 /*
 158  * Register a watch on the given path, using the given xenbus_watch structure
 159  * for storage, and the given callback function as the callback.  Return 0 on
 160  * success, or errno on error.  On success, the given path will be saved as
 161  * watch->node, and remains the caller's to free.  On error, watch->node will
 162  * be NULL, the device will switch to XenbusStateClosing, and the error will
 163  * be saved in the store.
 164  */
 165 extern int xenbus_watch_path(struct xenbus_device *dev, const char *path,
 166                         struct xenbus_watch *watch,
 167                         void (*callback)(struct xenbus_watch *,
 168                         const char **, unsigned int));
 169
 170
 171 /*
 172  * Register a watch on the given path/path2, using the given xenbus_watch
 173  * structure for storage, and the given callback function as the callback.
 174  * Return 0 on success, or errno on error.  On success, the watched path
 175  * (path/path2) will be saved as watch->node, and becomes the caller's to
 176  * kfree().  On error, watch->node will be NULL, so the caller has nothing to
 177  * free, the device will switch to XenbusStateClosing, and the error will be
 178  * saved in the store.
 179  */
 180 extern int xenbus_watch_path2(struct xenbus_device *dev, const char *path,
 181                         const char *path2, struct xenbus_watch *watch,
 182                         void (*callback)(struct xenbus_watch *,
 183                         const char **, unsigned int));
 184
 185
 186 /*
 187  * Advertise in the store a change of the given driver to the given new_state.
 188  * Perform the change inside the given transaction xbt.  xbt may be NULL, in
 189  * which case this is performed inside its own transaction.  Return 0 on
 190  * success, or errno on error.  On error, the device will switch to
 191  * XenbusStateClosing, and the error will be saved in the store.
 192  */
 193 extern int xenbus_switch_state(struct xenbus_device *dev,
 194                         xenbus_transaction_t xbt,
 195                         XenbusState new_state);
 196
 197
 198 /*
 199  * Grant access to the given ring_mfn to the peer of the given device.  Return
 200  * 0 on success, or errno on error.  On error, the device will switch to
 201  * XenbusStateClosing, and the error will be saved in the store.
 202  */
 203 extern int xenbus_grant_ring(struct xenbus_device *dev, unsigned long ring_mfn);
 204
 205
 206 /*
 207  * Allocate an event channel for the given xenbus_device, assigning the newly
 208  * created local port to *port.  Return 0 on success, or errno on error.  On
 209  * error, the device will switch to XenbusStateClosing, and the error will be
 210  * saved in the store.
 211  */
 212 extern int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port);
 213
 214
 215 /*
 216  * Return the state of the driver rooted at the given store path, or
 217  * XenbusStateClosed if no state can be read.
 218  */
 219 extern XenbusState xenbus_read_driver_state(const char *path);
 220
 221
 222 /*
 223  * Report the given negative errno into the store, along with the given
 224  * formatted message.
 225  */
 226 extern void xenbus_dev_error(struct xenbus_device *dev, int err,
 227         const char *fmt, ...);
 228
 229
 230 /*
 231  * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
 232  * xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly
 233  * closedown of this driver and its peer.
 234  */
 235 extern void xenbus_dev_fatal(struct xenbus_device *dev,
 236         int err, const char *fmt, ...);
 237
 238 /* Clear any error. */
 239 extern void xenbus_dev_ok(struct xenbus_device *dev);
 240
 241 /*
 242  * Set up watches on other end of split device.
 243  */
 244 extern int talk_to_otherend(struct xenbus_device *dev);
 245
 246 #define XENSTORE_DOWN   0       /* xenstore is down */
 247 #define XENSTORE_UP     1       /* xenstore is up */
 248
 249 /*
 250  * Register a notify callback function.
 251  */
 252 extern int xs_register_xenbus_callback(void (*callback)(int));
 253
 254 /*
 255  * Notify clients that xenstore is up
 256  */
 257 extern void xs_notify_xenstore_up(void);
 258
 259 /*
 260  * Notify clients that xenstore is down
 261  */
 262 extern void xs_notify_xenstore_down(void);
 263
 264 struct xsd_sockmsg;
 265
 266 extern int xenbus_dev_request_and_reply(struct xsd_sockmsg *, void **);
 267
 268 #ifdef  __cplusplus
 269 }
 270 #endif
 271
 272 #endif /* _SYS_XENBUS_H */