| 1 | /* $NetBSD: xenbus.h,v 1.13 2011/12/07 15:47:42 cegger Exp $ */ |
| 2 | /****************************************************************************** |
| 3 | * xenbus.h |
| 4 | * |
| 5 | * Talks to Xen Store to figure out what devices we have. |
| 6 | * |
| 7 | * Copyright (C) 2005 Rusty Russell, IBM Corporation |
| 8 | * Copyright (C) 2005 XenSource Ltd. |
| 9 | * |
| 10 | * This file may be distributed separately from the Linux kernel, or |
| 11 | * incorporated into other software packages, subject to the following license: |
| 12 | * |
| 13 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 14 | * of this source file (the "Software"), to deal in the Software without |
| 15 | * restriction, including without limitation the rights to use, copy, modify, |
| 16 | * merge, publish, distribute, sublicense, and/or sell copies of the Software, |
| 17 | * and to permit persons to whom the Software is furnished to do so, subject to |
| 18 | * the following conditions: |
| 19 | * |
| 20 | * The above copyright notice and this permission notice shall be included in |
| 21 | * all copies or substantial portions of the Software. |
| 22 | * |
| 23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 24 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 25 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 26 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 27 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 28 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| 29 | * IN THE SOFTWARE. |
| 30 | */ |
| 31 | |
| 32 | #ifndef _ASM_XEN_XENBUS_H |
| 33 | #define _ASM_XEN_XENBUS_H |
| 34 | |
| 35 | #include <sys/device.h> |
| 36 | #include <sys/queue.h> |
| 37 | #include <xen/xen-public/xen.h> |
| 38 | #include <xen/xen-public/io/xenbus.h> |
| 39 | #include <xen/xen-public/io/xs_wire.h> |
| 40 | #include <xen/xen-public/grant_table.h> /* for grant_ref_t */ |
| 41 | |
| 42 | /* xenbus to hypervisor attach */ |
| 43 | struct xenbus_attach_args { |
| 44 | const char *xa_device; |
| 45 | int xa_handle; |
| 46 | }; |
| 47 | |
| 48 | /* devices to xenbus attach */ |
| 49 | struct xenbusdev_attach_args { |
| 50 | const char *xa_type; |
| 51 | int xa_id; |
| 52 | struct xenbus_device *xa_xbusd; |
| 53 | }; |
| 54 | |
| 55 | /* Register callback to watch this node. */ |
| 56 | struct xenbus_watch { |
| 57 | SLIST_ENTRY(xenbus_watch) watch_next; |
| 58 | |
| 59 | /* Path being watched. */ |
| 60 | char *node; |
| 61 | |
| 62 | /* Callback (executed in a process context with no locks held). */ |
| 63 | void (*xbw_callback)(struct xenbus_watch *, |
| 64 | const char **vec, unsigned int len); |
| 65 | struct xenbus_device *xbw_dev; |
| 66 | }; |
| 67 | |
| 68 | |
| 69 | /* |
| 70 | * A xenbus device. Note that the malloced memory will be larger than |
| 71 | * sizeof(xenbus_device) to have the storage for xbusd_path, so xbusd_path |
| 72 | * has to be the last entry. |
| 73 | */ |
| 74 | typedef enum { |
| 75 | XENBUS_FRONTEND_DEVICE, |
| 76 | XENBUS_BACKEND_DEVICE |
| 77 | } xenbusdev_type_t; |
| 78 | |
| 79 | struct xenbus_device { |
| 80 | SLIST_ENTRY(xenbus_device) xbusd_entries; |
| 81 | char *xbusd_otherend; /* the otherend path */ |
| 82 | int xbusd_otherend_id; /* the otherend's id */ |
| 83 | /* callback for otherend change */ |
| 84 | void (*xbusd_otherend_changed)(void *, XenbusState); |
| 85 | xenbusdev_type_t xbusd_type; |
| 86 | union { |
| 87 | struct { |
| 88 | device_t f_dev; |
| 89 | } f; |
| 90 | struct { |
| 91 | void *b_cookie; /* private to backend driver */ |
| 92 | int (*b_detach)(void *); |
| 93 | } b; |
| 94 | } xbusd_u; |
| 95 | int xbusd_has_error; |
| 96 | /* for xenbus internal use */ |
| 97 | struct xenbus_watch xbusd_otherend_watch; |
| 98 | const char xbusd_path[1]; /* our path */ |
| 99 | }; |
| 100 | |
| 101 | /* |
| 102 | * frontend devices use the normal autoconf(9) framework to attach. |
| 103 | * backend drivers need something more clever because we want the |
| 104 | * domain's name or uid in the device's name. Each backend driver registers |
| 105 | * to xenbus. |
| 106 | */ |
| 107 | |
| 108 | struct xenbus_backend_driver { |
| 109 | SLIST_ENTRY(xenbus_backend_driver) xbakd_entries; |
| 110 | int (*xbakd_create) (struct xenbus_device *); /* called for new devs */ |
| 111 | const char *xbakd_type; /* device type we register for */ |
| 112 | }; |
| 113 | |
| 114 | void xenbus_backend_register(struct xenbus_backend_driver *); |
| 115 | |
| 116 | struct xenbus_transaction; |
| 117 | |
| 118 | int xenbus_directory(struct xenbus_transaction *t, |
| 119 | const char *dir, const char *node, unsigned int *num, |
| 120 | char ***); |
| 121 | int xenbus_read(struct xenbus_transaction *t, |
| 122 | const char *dir, const char *node, unsigned int *len, |
| 123 | char **); |
| 124 | int xenbus_read_ul(struct xenbus_transaction *, |
| 125 | const char *, const char *, unsigned long *, int); |
| 126 | int xenbus_read_ull(struct xenbus_transaction *, |
| 127 | const char *, const char *, unsigned long long *, int); |
| 128 | int xenbus_write(struct xenbus_transaction *t, |
| 129 | const char *dir, const char *node, const char *string); |
| 130 | int xenbus_mkdir(struct xenbus_transaction *t, |
| 131 | const char *dir, const char *node); |
| 132 | int xenbus_exists(struct xenbus_transaction *t, |
| 133 | const char *dir, const char *node); |
| 134 | int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node); |
| 135 | struct xenbus_transaction *xenbus_transaction_start(void); |
| 136 | int xenbus_transaction_end(struct xenbus_transaction *t, int abort); |
| 137 | |
| 138 | /* Single read and scanf: returns -errno or num scanned if > 0. */ |
| 139 | int xenbus_scanf(struct xenbus_transaction *t, |
| 140 | const char *dir, const char *node, const char *fmt, ...) |
| 141 | __attribute__((format(scanf, 4, 5))); |
| 142 | |
| 143 | /* Single printf and write: returns -errno or 0. */ |
| 144 | int xenbus_printf(struct xenbus_transaction *t, |
| 145 | const char *dir, const char *node, const char *fmt, ...) |
| 146 | __attribute__((format(printf, 4, 5))); |
| 147 | |
| 148 | /* Generic read function: NULL-terminated triples of name, |
| 149 | * sprintf-style type string, and pointer. Returns 0 or errno.*/ |
| 150 | int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...); |
| 151 | |
| 152 | /* notifer routines for when the xenstore comes up */ |
| 153 | // XXX int register_xenstore_notifier(struct notifier_block *nb); |
| 154 | // XXX void unregister_xenstore_notifier(struct notifier_block *nb); |
| 155 | |
| 156 | int register_xenbus_watch(struct xenbus_watch *watch); |
| 157 | void unregister_xenbus_watch(struct xenbus_watch *watch); |
| 158 | void xs_suspend(void); |
| 159 | void xs_resume(void); |
| 160 | |
| 161 | /* Used by xenbus_dev to borrow kernel's store connection. */ |
| 162 | int xenbus_dev_request_and_reply(struct xsd_sockmsg *msg, void **); |
| 163 | |
| 164 | void xenbus_probe(void *); |
| 165 | |
| 166 | int xenbus_free_device(struct xenbus_device *); |
| 167 | |
| 168 | #define XENBUS_IS_ERR_READ(str) ({ \ |
| 169 | if (!IS_ERR(str) && strlen(str) == 0) { \ |
| 170 | kfree(str); \ |
| 171 | str = ERR_PTR(-ERANGE); \ |
| 172 | } \ |
| 173 | IS_ERR(str); \ |
| 174 | }) |
| 175 | |
| 176 | #define XENBUS_EXIST_ERR(err) ((err) == -ENOENT || (err) == -ERANGE) |
| 177 | |
| 178 | |
| 179 | /** |
| 180 | * Register a watch on the given path, using the given xenbus_watch structure |
| 181 | * for storage, and the given callback function as the callback. Return 0 on |
| 182 | * success, or -errno on error. On success, the given path will be saved as |
| 183 | * watch->node, and remains the caller's to free. On error, watch->node will |
| 184 | * be NULL, the device will switch to XenbusStateClosing, and the error will |
| 185 | * be saved in the store. |
| 186 | */ |
| 187 | int xenbus_watch_path(struct xenbus_device *dev, char *path, |
| 188 | struct xenbus_watch *watch, |
| 189 | void (*callback)(struct xenbus_watch *, |
| 190 | const char **, unsigned int)); |
| 191 | |
| 192 | |
| 193 | /** |
| 194 | * Register a watch on the given path/path2, using the given xenbus_watch |
| 195 | * structure for storage, and the given callback function as the callback. |
| 196 | * Return 0 on success, or -errno on error. On success, the watched path |
| 197 | * (path/path2) will be saved as watch->node, and becomes the caller's to |
| 198 | * kfree(). On error, watch->node will be NULL, so the caller has nothing to |
| 199 | * free, the device will switch to XenbusStateClosing, and the error will be |
| 200 | * saved in the store. |
| 201 | */ |
| 202 | int xenbus_watch_path2(struct xenbus_device *dev, const char *path, |
| 203 | const char *path2, struct xenbus_watch *watch, |
| 204 | void (*callback)(struct xenbus_watch *, |
| 205 | const char **, unsigned int)); |
| 206 | |
| 207 | |
| 208 | /** |
| 209 | * Advertise in the store a change of the given driver to the given new_state. |
| 210 | * Perform the change inside the given transaction xbt. xbt may be NULL, in |
| 211 | * which case this is performed inside its own transaction. Return 0 on |
| 212 | * success, or -errno on error. On error, the device will switch to |
| 213 | * XenbusStateClosing, and the error will be saved in the store. |
| 214 | */ |
| 215 | int xenbus_switch_state(struct xenbus_device *dev, |
| 216 | struct xenbus_transaction *xbt, |
| 217 | XenbusState new_state); |
| 218 | |
| 219 | |
| 220 | /** |
| 221 | * Grant access to the given ring_mfn to the peer of the given device. Return |
| 222 | * 0 on success, or -errno on error. On error, the device will switch to |
| 223 | * XenbusStateClosing, and the error will be saved in the store. |
| 224 | */ |
| 225 | int xenbus_grant_ring(struct xenbus_device *, paddr_t, grant_ref_t *); |
| 226 | |
| 227 | |
| 228 | /** |
| 229 | * Allocate an event channel for the given xenbus_device, assigning the newly |
| 230 | * created local port to *port. Return 0 on success, or -errno on error. On |
| 231 | * error, the device will switch to XenbusStateClosing, and the error will be |
| 232 | * saved in the store. |
| 233 | */ |
| 234 | int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port); |
| 235 | |
| 236 | |
| 237 | /** |
| 238 | * Return the state of the driver rooted at the given store path, or |
| 239 | * XenbusStateClosed if no state can be read. |
| 240 | */ |
| 241 | XenbusState xenbus_read_driver_state(const char *path); |
| 242 | |
| 243 | |
| 244 | /*** |
| 245 | * Report the given negative errno into the store, along with the given |
| 246 | * formatted message. |
| 247 | */ |
| 248 | void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, |
| 249 | ...); |
| 250 | |
| 251 | |
| 252 | /*** |
| 253 | * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by |
| 254 | * xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly |
| 255 | * closedown of this driver and its peer. |
| 256 | */ |
| 257 | void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, |
| 258 | ...); |
| 259 | |
| 260 | bool xenbus_device_suspend(struct xenbus_device *); |
| 261 | bool xenbus_device_resume(struct xenbus_device *); |
| 262 | |
| 263 | #endif /* _ASM_XEN_XENBUS_H */ |
| 264 | |
| 265 | /* |
| 266 | * Local variables: |
| 267 | * c-file-style: "linux" |
| 268 | * indent-tabs-mode: t |
| 269 | * c-indent-level: 8 |
| 270 | * c-basic-offset: 8 |
| 271 | * tab-width: 8 |
| 272 | * End: |
| 273 | */ |
| 274 | |