xenbus.h revision 1.3
1 /* $NetBSD: xenbus.h,v 1.3 2006/03/16 23:08:08 bouyer 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 <machine/xen3-public/io/xenbus.h> 38 #include <machine/xen3-public/io/xs_wire.h> 39 40 /* xenbus to hypervisor attach */ 41 struct xenbus_attach_args { 42 const char *xa_device; 43 int xa_handle; 44 }; 45 46 /* devices to xenbus attach */ 47 struct xenbusdev_attach_args { 48 const char *xa_type; 49 int xa_id; 50 struct xenbus_device *xa_xbusd; 51 }; 52 53 /* Register callback to watch this node. */ 54 struct xenbus_watch { 55 SLIST_ENTRY(xenbus_watch) watch_next; 56 57 /* Path being watched. */ 58 char *node; 59 60 /* Callback (executed in a process context with no locks held). */ 61 void (*xbw_callback)(struct xenbus_watch *, 62 const char **vec, unsigned int len); 63 struct xenbus_device *xbw_dev; 64 }; 65 66 67 /* A xenbus device. */ 68 struct xenbus_device { 69 const char xbusd_path[80]; /* our path */ 70 char *xbusd_otherend; /* the otherend path */ 71 int xbusd_otherend_id; /* the otherend's id */ 72 /* callback for otherend change */ 73 void (*xbusd_otherend_changed)(void *, XenbusState); 74 void *xbusd_data; 75 int xbusd_has_error; 76 /* for xenbus internal use */ 77 struct xenbus_watch xbusd_otherend_watch; 78 }; 79 80 struct xenbus_device_id 81 { 82 /* .../device/<device_type>/<identifier> */ 83 char devicetype[32]; /* General class of device. */ 84 }; 85 86 /* A xenbus driver. */ 87 struct xenbus_driver { 88 char *name; 89 struct module *owner; 90 const struct xenbus_device_id *ids; 91 int (*probe)(struct xenbus_device *dev, 92 const struct xenbus_device_id *id); 93 void (*otherend_changed)(struct xenbus_device *dev, 94 XenbusState backend_state); 95 int (*remove)(struct xenbus_device *dev); 96 int (*suspend)(struct xenbus_device *dev); 97 int (*resume)(struct xenbus_device *dev); 98 int (*hotplug)(struct xenbus_device *, char **, int, char *, int); 99 int (*read_otherend_details)(struct xenbus_device *dev); 100 }; 101 102 int xenbus_register_frontend(struct xenbus_driver *drv); 103 int xenbus_register_backend(struct xenbus_driver *drv); 104 void xenbus_unregister_driver(struct xenbus_driver *drv); 105 106 struct xenbus_transaction; 107 108 int xenbus_directory(struct xenbus_transaction *t, 109 const char *dir, const char *node, unsigned int *num, 110 char ***); 111 int xenbus_read(struct xenbus_transaction *t, 112 const char *dir, const char *node, unsigned int *len, 113 char **); 114 int xenbus_read_ul(struct xenbus_transaction *, 115 const char *, const char *, unsigned long *); 116 int xenbus_write(struct xenbus_transaction *t, 117 const char *dir, const char *node, const char *string); 118 int xenbus_mkdir(struct xenbus_transaction *t, 119 const char *dir, const char *node); 120 int xenbus_exists(struct xenbus_transaction *t, 121 const char *dir, const char *node); 122 int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node); 123 struct xenbus_transaction *xenbus_transaction_start(void); 124 int xenbus_transaction_end(struct xenbus_transaction *t, int abort); 125 126 /* Single read and scanf: returns -errno or num scanned if > 0. */ 127 int xenbus_scanf(struct xenbus_transaction *t, 128 const char *dir, const char *node, const char *fmt, ...) 129 __attribute__((format(scanf, 4, 5))); 130 131 /* Single printf and write: returns -errno or 0. */ 132 int xenbus_printf(struct xenbus_transaction *t, 133 const char *dir, const char *node, const char *fmt, ...) 134 __attribute__((format(printf, 4, 5))); 135 136 /* Generic read function: NULL-terminated triples of name, 137 * sprintf-style type string, and pointer. Returns 0 or errno.*/ 138 int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...); 139 140 /* notifer routines for when the xenstore comes up */ 141 // XXX int register_xenstore_notifier(struct notifier_block *nb); 142 // XXX void unregister_xenstore_notifier(struct notifier_block *nb); 143 144 int register_xenbus_watch(struct xenbus_watch *watch); 145 void unregister_xenbus_watch(struct xenbus_watch *watch); 146 void xs_suspend(void); 147 void xs_resume(void); 148 149 /* Used by xenbus_dev to borrow kernel's store connection. */ 150 int xenbus_dev_request_and_reply(struct xsd_sockmsg *msg, void **); 151 152 /* Called from xen core code. */ 153 void xenbus_suspend(void); 154 void xenbus_resume(void); 155 156 void xenbus_probe(void *); 157 158 #define XENBUS_IS_ERR_READ(str) ({ \ 159 if (!IS_ERR(str) && strlen(str) == 0) { \ 160 kfree(str); \ 161 str = ERR_PTR(-ERANGE); \ 162 } \ 163 IS_ERR(str); \ 164 }) 165 166 #define XENBUS_EXIST_ERR(err) ((err) == -ENOENT || (err) == -ERANGE) 167 168 169 /** 170 * Register a watch on the given path, using the given xenbus_watch structure 171 * for storage, and the given callback function as the callback. Return 0 on 172 * success, or -errno on error. On success, the given path will be saved as 173 * watch->node, and remains the caller's to free. On error, watch->node will 174 * be NULL, the device will switch to XenbusStateClosing, and the error will 175 * be saved in the store. 176 */ 177 int xenbus_watch_path(struct xenbus_device *dev, char *path, 178 struct xenbus_watch *watch, 179 void (*callback)(struct xenbus_watch *, 180 const char **, unsigned int)); 181 182 183 /** 184 * Register a watch on the given path/path2, using the given xenbus_watch 185 * structure for storage, and the given callback function as the callback. 186 * Return 0 on success, or -errno on error. On success, the watched path 187 * (path/path2) will be saved as watch->node, and becomes the caller's to 188 * kfree(). On error, watch->node will be NULL, so the caller has nothing to 189 * free, the device will switch to XenbusStateClosing, and the error will be 190 * saved in the store. 191 */ 192 int xenbus_watch_path2(struct xenbus_device *dev, const char *path, 193 const char *path2, struct xenbus_watch *watch, 194 void (*callback)(struct xenbus_watch *, 195 const char **, unsigned int)); 196 197 198 /** 199 * Advertise in the store a change of the given driver to the given new_state. 200 * Perform the change inside the given transaction xbt. xbt may be NULL, in 201 * which case this is performed inside its own transaction. Return 0 on 202 * success, or -errno on error. On error, the device will switch to 203 * XenbusStateClosing, and the error will be saved in the store. 204 */ 205 int xenbus_switch_state(struct xenbus_device *dev, 206 struct xenbus_transaction *xbt, 207 XenbusState new_state); 208 209 210 /** 211 * Grant access to the given ring_mfn to the peer of the given device. Return 212 * 0 on 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_grant_ring(struct xenbus_device *, paddr_t, grant_ref_t *); 216 217 218 /** 219 * Allocate an event channel for the given xenbus_device, assigning the newly 220 * created local port to *port. Return 0 on success, or -errno on error. On 221 * error, the device will switch to XenbusStateClosing, and the error will be 222 * saved in the store. 223 */ 224 int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port); 225 226 227 /** 228 * Return the state of the driver rooted at the given store path, or 229 * XenbusStateClosed if no state can be read. 230 */ 231 XenbusState xenbus_read_driver_state(const char *path); 232 233 234 /*** 235 * Report the given negative errno into the store, along with the given 236 * formatted message. 237 */ 238 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, 239 ...); 240 241 242 /*** 243 * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by 244 * xenbus_switch_state(dev, NULL, XenbusStateClosing) to schedule an orderly 245 * closedown of this driver and its peer. 246 */ 247 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, 248 ...); 249 250 251 #endif /* _ASM_XEN_XENBUS_H */ 252 253 /* 254 * Local variables: 255 * c-file-style: "linux" 256 * indent-tabs-mode: t 257 * c-indent-level: 8 258 * c-basic-offset: 8 259 * tab-width: 8 260 * End: 261 */ 262
Indexes created Tue Sep 23 22:09:46 GMT 2025