1 /* $NetBSD: xenbus_comms.c,v 1.14 2011/09/20 00:12:24 jym Exp $ */ 2 /****************************************************************************** 3 * xenbus_comms.c 4 * 5 * Low level code to talks to Xen Store: ringbuffer and event channel. 6 * 7 * Copyright (C) 2005 Rusty Russell, IBM Corporation 8 * 9 * This file may be distributed separately from the Linux kernel, or 10 * incorporated into other software packages, subject to the following license: 11 * 12 * Permission is hereby granted, free of charge, to any person obtaining a copy 13 * of this source file (the "Software"), to deal in the Software without 14 * restriction, including without limitation the rights to use, copy, modify, 15 * merge, publish, distribute, sublicense, and/or sell copies of the Software, 16 * and to permit persons to whom the Software is furnished to do so, subject to 17 * the following conditions: 18 * 19 * The above copyright notice and this permission notice shall be included in 20 * all copies or substantial portions of the Software. 21 * 22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 25 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 28 * IN THE SOFTWARE. 29 */ 30 31 #include <sys/cdefs.h> 32 __KERNEL_RCSID(0, "$NetBSD: xenbus_comms.c,v 1.14 2011/09/20 00:12:24 jym Exp $"); 33 34 #include <sys/types.h> 35 #include <sys/null.h> 36 #include <sys/errno.h> 37 #include <sys/param.h> 38 #include <sys/proc.h> 39 #include <sys/systm.h> 40 41 #include <xen/xen.h> /* for xendomain_is_dom0() */ 42 #include <xen/hypervisor.h> 43 #include <xen/evtchn.h> 44 #include <xen/xenbus.h> 45 #include "xenbus_comms.h" 46 47 #undef XENDEBUG 48 #ifdef XENDEBUG 49 #define XENPRINTF(x) printf x 50 #else 51 #define XENPRINTF(x) 52 #endif 53 54 struct xenstore_domain_interface *xenstore_interface; 55 56 extern int xenstored_ready; 57 // static DECLARE_WORK(probe_work, xenbus_probe, NULL); 58 59 static int wake_waiting(void *); 60 static int check_indexes(XENSTORE_RING_IDX, XENSTORE_RING_IDX); 61 static void *get_output_chunk(XENSTORE_RING_IDX, XENSTORE_RING_IDX, 62 char *, uint32_t *); 63 static const void *get_input_chunk(XENSTORE_RING_IDX, XENSTORE_RING_IDX, 64 const char *, uint32_t *); 65 66 67 static inline struct xenstore_domain_interface * 68 xenstore_domain_interface(void) 69 { 70 return xenstore_interface; 71 } 72 73 static int 74 wake_waiting(void *arg) 75 { 76 if (__predict_false(xenstored_ready == 0 && xendomain_is_dom0())) { 77 xenstored_ready = 1; 78 wakeup(&xenstored_ready); 79 } 80 81 wakeup(&xenstore_interface); 82 return 1; 83 } 84 85 static int 86 check_indexes(XENSTORE_RING_IDX cons, XENSTORE_RING_IDX prod) 87 { 88 return ((prod - cons) <= XENSTORE_RING_SIZE); 89 } 90 91 static void * 92 get_output_chunk(XENSTORE_RING_IDX cons, 93 XENSTORE_RING_IDX prod, 94 char *buf, uint32_t *len) 95 { 96 *len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod); 97 if ((XENSTORE_RING_SIZE - (prod - cons)) < *len) 98 *len = XENSTORE_RING_SIZE - (prod - cons); 99 return buf + MASK_XENSTORE_IDX(prod); 100 } 101 102 static const void * 103 get_input_chunk(XENSTORE_RING_IDX cons, 104 XENSTORE_RING_IDX prod, 105 const char *buf, uint32_t *len) 106 { 107 *len = XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(cons); 108 if ((prod - cons) < *len) 109 *len = prod - cons; 110 return buf + MASK_XENSTORE_IDX(cons); 111 } 112 113 int 114 xb_write(const void *data, unsigned len) 115 { 116 struct xenstore_domain_interface *intf = xenstore_domain_interface(); 117 XENSTORE_RING_IDX cons, prod; 118 119 int s = spltty(); 120 121 while (len != 0) { 122 void *dst; 123 unsigned int avail; 124 125 while ((intf->req_prod - intf->req_cons) == XENSTORE_RING_SIZE) { 126 XENPRINTF(("xb_write tsleep\n")); 127 tsleep(&xenstore_interface, PRIBIO, "wrst", 0); 128 XENPRINTF(("xb_write tsleep done\n")); 129 } 130 131 /* Read indexes, then verify. */ 132 cons = intf->req_cons; 133 prod = intf->req_prod; 134 xen_rmb(); 135 if (!check_indexes(cons, prod)) { 136 splx(s); 137 return EIO; 138 } 139 140 dst = get_output_chunk(cons, prod, intf->req, &avail); 141 if (avail == 0) 142 continue; 143 if (avail > len) 144 avail = len; 145 146 memcpy(dst, data, avail); 147 data = (const char *)data + avail; 148 len -= avail; 149 150 /* Other side must not see new header until data is there. */ 151 xen_rmb(); 152 intf->req_prod += avail; 153 xen_rmb(); 154 155 hypervisor_notify_via_evtchn(xen_start_info.store_evtchn); 156 } 157 158 splx(s); 159 return 0; 160 } 161 162 int 163 xb_read(void *data, unsigned len) 164 { 165 struct xenstore_domain_interface *intf = xenstore_domain_interface(); 166 XENSTORE_RING_IDX cons, prod; 167 168 int s = spltty(); 169 170 while (len != 0) { 171 unsigned int avail; 172 const char *src; 173 174 while (intf->rsp_cons == intf->rsp_prod) 175 tsleep(&xenstore_interface, PRIBIO, "rdst", 0); 176 177 /* Read indexes, then verify. */ 178 cons = intf->rsp_cons; 179 prod = intf->rsp_prod; 180 xen_rmb(); 181 if (!check_indexes(cons, prod)) { 182 XENPRINTF(("xb_read EIO\n")); 183 splx(s); 184 return EIO; 185 } 186 187 src = get_input_chunk(cons, prod, intf->rsp, &avail); 188 if (avail == 0) 189 continue; 190 if (avail > len) 191 avail = len; 192 193 /* We must read header before we read data. */ 194 xen_rmb(); 195 196 memcpy(data, src, avail); 197 data = (char *)data + avail; 198 len -= avail; 199 200 /* Other side must not see free space until we've copied out */ 201 xen_rmb(); 202 intf->rsp_cons += avail; 203 xen_rmb(); 204 205 XENPRINTF(("Finished read of %i bytes (%i to go)\n", 206 avail, len)); 207 208 hypervisor_notify_via_evtchn(xen_start_info.store_evtchn); 209 } 210 211 splx(s); 212 return 0; 213 } 214 215 /* Set up interrupt handler of store event channel. */ 216 int 217 xb_init_comms(device_t dev) 218 { 219 int evtchn; 220 221 evtchn = xen_start_info.store_evtchn; 222 223 event_set_handler(evtchn, wake_waiting, NULL, IPL_TTY, "xenbus"); 224 hypervisor_enable_event(evtchn); 225 aprint_verbose_dev(dev, "using event channel %d\n", evtchn); 226 227 return 0; 228 } 229 230 void 231 xb_suspend_comms(device_t dev) 232 { 233 int evtchn; 234 235 evtchn = xen_start_info.store_evtchn; 236 237 hypervisor_mask_event(evtchn); 238 event_remove_handler(evtchn, wake_waiting, NULL); 239 aprint_verbose_dev(dev, "removed event channel %d\n", evtchn); 240 } 241 242 /* 243 * Local variables: 244 * c-file-style: "linux" 245 * indent-tabs-mode: t 246 * c-indent-level: 8 247 * c-basic-offset: 8 248 * tab-width: 8 249 * End: 250 */ 251