1 /*-
2 * Copyright (c) 2016 Microsoft Corp.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
10 * disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include <sys/param.h>
28 #include <sys/lock.h>
29 #include <sys/malloc.h>
30 #include <sys/mutex.h>
31 #include <sys/proc.h>
32 #include <sys/systm.h>
33
34 #include <vm/vm.h>
35 #include <vm/vm_extern.h>
36 #include <vm/pmap.h>
37
38 #include <dev/hyperv/include/vmbus_xact.h>
39
40 struct vmbus_xact {
41 struct vmbus_xact_ctx *x_ctx;
42 void *x_priv;
43
44 void *x_req;
45
46 const void *x_resp;
47 size_t x_resp_len;
48 void *x_resp0;
49 };
50
51 struct vmbus_xact_ctx {
52 size_t xc_req_size;
53 size_t xc_resp_size;
54 size_t xc_priv_size;
55
56 struct mtx xc_lock;
57 /*
58 * Protected by xc_lock.
59 */
60 uint32_t xc_flags; /* VMBUS_XACT_CTXF_ */
61 struct vmbus_xact *xc_free;
62 struct vmbus_xact *xc_active;
63 struct vmbus_xact *xc_orphan;
64 };
65
66 #define VMBUS_XACT_CTXF_DESTROY 0x0001
67
68 static struct vmbus_xact *vmbus_xact_alloc(struct vmbus_xact_ctx *,
69 bus_dma_tag_t);
70 static void vmbus_xact_free(struct vmbus_xact *);
71 static struct vmbus_xact *vmbus_xact_get1(struct vmbus_xact_ctx *,
72 uint32_t);
73 static const void *vmbus_xact_wait1(struct vmbus_xact *, size_t *,
74 bool);
75 static const void *vmbus_xact_return(struct vmbus_xact *,
76 size_t *);
77 static void vmbus_xact_save_resp(struct vmbus_xact *,
78 const void *, size_t);
79 static void vmbus_xact_ctx_free(struct vmbus_xact_ctx *);
80
81 static struct vmbus_xact *
vmbus_xact_alloc(struct vmbus_xact_ctx * ctx,bus_dma_tag_t parent_dtag)82 vmbus_xact_alloc(struct vmbus_xact_ctx *ctx, bus_dma_tag_t parent_dtag)
83 {
84 struct vmbus_xact *xact;
85
86 xact = malloc(sizeof(*xact), M_DEVBUF, M_WAITOK | M_ZERO);
87 xact->x_ctx = ctx;
88
89 /* XXX assume that page aligned is enough */
90 xact->x_req = contigmalloc(ctx->xc_req_size, M_DEVBUF,
91 M_WAITOK | M_ZERO, 0ul, ~0ul, PAGE_SIZE, 0);
92 if (xact->x_req == NULL) {
93 free(xact, M_DEVBUF);
94 return (NULL);
95 }
96 if (ctx->xc_priv_size != 0)
97 xact->x_priv = malloc(ctx->xc_priv_size, M_DEVBUF, M_WAITOK);
98 xact->x_resp0 = malloc(ctx->xc_resp_size, M_DEVBUF, M_WAITOK);
99
100 return (xact);
101 }
102
103 static void
vmbus_xact_free(struct vmbus_xact * xact)104 vmbus_xact_free(struct vmbus_xact *xact)
105 {
106
107 contigfree(xact->x_req, xact->x_ctx->xc_req_size, M_DEVBUF);
108 free(xact->x_resp0, M_DEVBUF);
109 if (xact->x_priv != NULL)
110 free(xact->x_priv, M_DEVBUF);
111 free(xact, M_DEVBUF);
112 }
113
114 static struct vmbus_xact *
vmbus_xact_get1(struct vmbus_xact_ctx * ctx,uint32_t dtor_flag)115 vmbus_xact_get1(struct vmbus_xact_ctx *ctx, uint32_t dtor_flag)
116 {
117 struct vmbus_xact *xact;
118
119 mtx_lock(&ctx->xc_lock);
120
121 while ((ctx->xc_flags & dtor_flag) == 0 && ctx->xc_free == NULL)
122 mtx_sleep(&ctx->xc_free, &ctx->xc_lock, 0, "gxact", 0);
123 if (ctx->xc_flags & dtor_flag) {
124 /* Being destroyed */
125 xact = NULL;
126 } else {
127 xact = ctx->xc_free;
128 KASSERT(xact != NULL, ("no free xact"));
129 KASSERT(xact->x_resp == NULL, ("xact has pending response"));
130 ctx->xc_free = NULL;
131 }
132
133 mtx_unlock(&ctx->xc_lock);
134
135 return (xact);
136 }
137
138 struct vmbus_xact_ctx *
vmbus_xact_ctx_create(bus_dma_tag_t dtag,size_t req_size,size_t resp_size,size_t priv_size)139 vmbus_xact_ctx_create(bus_dma_tag_t dtag, size_t req_size, size_t resp_size,
140 size_t priv_size)
141 {
142 struct vmbus_xact_ctx *ctx;
143
144 KASSERT(req_size > 0, ("request size is 0"));
145 KASSERT(resp_size > 0, ("response size is 0"));
146
147 ctx = malloc(sizeof(*ctx), M_DEVBUF, M_WAITOK | M_ZERO);
148 ctx->xc_req_size = req_size;
149 ctx->xc_resp_size = resp_size;
150 ctx->xc_priv_size = priv_size;
151
152 ctx->xc_free = vmbus_xact_alloc(ctx, dtag);
153 if (ctx->xc_free == NULL) {
154 free(ctx, M_DEVBUF);
155 return (NULL);
156 }
157
158 mtx_init(&ctx->xc_lock, "vmbus xact", NULL, MTX_DEF);
159
160 return (ctx);
161 }
162
163 bool
vmbus_xact_ctx_orphan(struct vmbus_xact_ctx * ctx)164 vmbus_xact_ctx_orphan(struct vmbus_xact_ctx *ctx)
165 {
166 mtx_lock(&ctx->xc_lock);
167 if (ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) {
168 mtx_unlock(&ctx->xc_lock);
169 return (false);
170 }
171 ctx->xc_flags |= VMBUS_XACT_CTXF_DESTROY;
172 mtx_unlock(&ctx->xc_lock);
173
174 wakeup(&ctx->xc_free);
175 wakeup(&ctx->xc_active);
176
177 ctx->xc_orphan = vmbus_xact_get1(ctx, 0);
178 if (ctx->xc_orphan == NULL)
179 panic("can't get xact");
180 return (true);
181 }
182
183 static void
vmbus_xact_ctx_free(struct vmbus_xact_ctx * ctx)184 vmbus_xact_ctx_free(struct vmbus_xact_ctx *ctx)
185 {
186 KASSERT(ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY,
187 ("xact ctx was not orphaned"));
188 KASSERT(ctx->xc_orphan != NULL, ("no orphaned xact"));
189
190 vmbus_xact_free(ctx->xc_orphan);
191 mtx_destroy(&ctx->xc_lock);
192 free(ctx, M_DEVBUF);
193 }
194
195 void
vmbus_xact_ctx_destroy(struct vmbus_xact_ctx * ctx)196 vmbus_xact_ctx_destroy(struct vmbus_xact_ctx *ctx)
197 {
198
199 vmbus_xact_ctx_orphan(ctx);
200 vmbus_xact_ctx_free(ctx);
201 }
202
203 struct vmbus_xact *
vmbus_xact_get(struct vmbus_xact_ctx * ctx,size_t req_len)204 vmbus_xact_get(struct vmbus_xact_ctx *ctx, size_t req_len)
205 {
206 struct vmbus_xact *xact;
207
208 if (req_len > ctx->xc_req_size)
209 panic("invalid request size %zu", req_len);
210
211 xact = vmbus_xact_get1(ctx, VMBUS_XACT_CTXF_DESTROY);
212 if (xact == NULL)
213 return (NULL);
214
215 memset(xact->x_req, 0, req_len);
216 return (xact);
217 }
218
219 void
vmbus_xact_put(struct vmbus_xact * xact)220 vmbus_xact_put(struct vmbus_xact *xact)
221 {
222 struct vmbus_xact_ctx *ctx = xact->x_ctx;
223
224 KASSERT(ctx->xc_active == NULL, ("pending active xact"));
225 xact->x_resp = NULL;
226
227 mtx_lock(&ctx->xc_lock);
228 KASSERT(ctx->xc_free == NULL, ("has free xact"));
229 ctx->xc_free = xact;
230 mtx_unlock(&ctx->xc_lock);
231 wakeup(&ctx->xc_free);
232 }
233
234 void *
vmbus_xact_req_data(const struct vmbus_xact * xact)235 vmbus_xact_req_data(const struct vmbus_xact *xact)
236 {
237
238 return (xact->x_req);
239 }
240
241 bus_addr_t
vmbus_xact_req_paddr(const struct vmbus_xact * xact)242 vmbus_xact_req_paddr(const struct vmbus_xact *xact)
243 {
244
245 return (pmap_kextract((vm_offset_t)xact->x_req));
246 }
247
248 void *
vmbus_xact_priv(const struct vmbus_xact * xact,size_t priv_len)249 vmbus_xact_priv(const struct vmbus_xact *xact, size_t priv_len)
250 {
251
252 if (priv_len > xact->x_ctx->xc_priv_size)
253 panic("invalid priv size %zu", priv_len);
254 return (xact->x_priv);
255 }
256
257 void
vmbus_xact_activate(struct vmbus_xact * xact)258 vmbus_xact_activate(struct vmbus_xact *xact)
259 {
260 struct vmbus_xact_ctx *ctx = xact->x_ctx;
261
262 KASSERT(xact->x_resp == NULL, ("xact has pending response"));
263
264 mtx_lock(&ctx->xc_lock);
265 KASSERT(ctx->xc_active == NULL, ("pending active xact"));
266 ctx->xc_active = xact;
267 mtx_unlock(&ctx->xc_lock);
268 }
269
270 void
vmbus_xact_deactivate(struct vmbus_xact * xact)271 vmbus_xact_deactivate(struct vmbus_xact *xact)
272 {
273 struct vmbus_xact_ctx *ctx = xact->x_ctx;
274
275 mtx_lock(&ctx->xc_lock);
276 KASSERT(ctx->xc_active == xact, ("xact mismatch"));
277 ctx->xc_active = NULL;
278 mtx_unlock(&ctx->xc_lock);
279 }
280
281 static const void *
vmbus_xact_return(struct vmbus_xact * xact,size_t * resp_len)282 vmbus_xact_return(struct vmbus_xact *xact, size_t *resp_len)
283 {
284 struct vmbus_xact_ctx *ctx = xact->x_ctx;
285 const void *resp;
286
287 mtx_assert(&ctx->xc_lock, MA_OWNED);
288 KASSERT(ctx->xc_active == xact, ("xact trashed"));
289
290 if ((ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) && xact->x_resp == NULL) {
291 uint8_t b = 0;
292
293 /*
294 * Orphaned and no response was received yet; fake up
295 * an one byte response.
296 */
297 printf("vmbus: xact ctx was orphaned w/ pending xact\n");
298 vmbus_xact_save_resp(ctx->xc_active, &b, sizeof(b));
299 }
300 KASSERT(xact->x_resp != NULL, ("no response"));
301
302 ctx->xc_active = NULL;
303
304 resp = xact->x_resp;
305 *resp_len = xact->x_resp_len;
306
307 return (resp);
308 }
309
310 static const void *
vmbus_xact_wait1(struct vmbus_xact * xact,size_t * resp_len,bool can_sleep)311 vmbus_xact_wait1(struct vmbus_xact *xact, size_t *resp_len,
312 bool can_sleep)
313 {
314 struct vmbus_xact_ctx *ctx = xact->x_ctx;
315 const void *resp;
316
317 mtx_lock(&ctx->xc_lock);
318
319 KASSERT(ctx->xc_active == xact, ("xact mismatch"));
320 while (xact->x_resp == NULL &&
321 (ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) == 0) {
322 if (can_sleep) {
323 mtx_sleep(&ctx->xc_active, &ctx->xc_lock, 0,
324 "wxact", 0);
325 } else {
326 mtx_unlock(&ctx->xc_lock);
327 DELAY(1000);
328 mtx_lock(&ctx->xc_lock);
329 }
330 }
331 resp = vmbus_xact_return(xact, resp_len);
332
333 mtx_unlock(&ctx->xc_lock);
334
335 return (resp);
336 }
337
338 const void *
vmbus_xact_wait(struct vmbus_xact * xact,size_t * resp_len)339 vmbus_xact_wait(struct vmbus_xact *xact, size_t *resp_len)
340 {
341
342 return (vmbus_xact_wait1(xact, resp_len, true /* can sleep */));
343 }
344
345 const void *
vmbus_xact_busywait(struct vmbus_xact * xact,size_t * resp_len)346 vmbus_xact_busywait(struct vmbus_xact *xact, size_t *resp_len)
347 {
348
349 return (vmbus_xact_wait1(xact, resp_len, false /* can't sleep */));
350 }
351
352 const void *
vmbus_xact_poll(struct vmbus_xact * xact,size_t * resp_len)353 vmbus_xact_poll(struct vmbus_xact *xact, size_t *resp_len)
354 {
355 struct vmbus_xact_ctx *ctx = xact->x_ctx;
356 const void *resp;
357
358 mtx_lock(&ctx->xc_lock);
359
360 KASSERT(ctx->xc_active == xact, ("xact mismatch"));
361 if (xact->x_resp == NULL &&
362 (ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) == 0) {
363 mtx_unlock(&ctx->xc_lock);
364 *resp_len = 0;
365 return (NULL);
366 }
367 resp = vmbus_xact_return(xact, resp_len);
368
369 mtx_unlock(&ctx->xc_lock);
370
371 return (resp);
372 }
373
374 static void
vmbus_xact_save_resp(struct vmbus_xact * xact,const void * data,size_t dlen)375 vmbus_xact_save_resp(struct vmbus_xact *xact, const void *data, size_t dlen)
376 {
377 struct vmbus_xact_ctx *ctx = xact->x_ctx;
378 size_t cplen = dlen;
379
380 mtx_assert(&ctx->xc_lock, MA_OWNED);
381
382 if (cplen > ctx->xc_resp_size) {
383 printf("vmbus: xact response truncated %zu -> %zu\n",
384 cplen, ctx->xc_resp_size);
385 cplen = ctx->xc_resp_size;
386 }
387
388 KASSERT(ctx->xc_active == xact, ("xact mismatch"));
389 memcpy(xact->x_resp0, data, cplen);
390 xact->x_resp_len = cplen;
391 xact->x_resp = xact->x_resp0;
392 }
393
394 void
vmbus_xact_wakeup(struct vmbus_xact * xact,const void * data,size_t dlen)395 vmbus_xact_wakeup(struct vmbus_xact *xact, const void *data, size_t dlen)
396 {
397 struct vmbus_xact_ctx *ctx = xact->x_ctx;
398 int do_wakeup = 0;
399
400 mtx_lock(&ctx->xc_lock);
401 /*
402 * NOTE:
403 * xc_active could be NULL, if the ctx has been orphaned.
404 */
405 if (ctx->xc_active != NULL) {
406 vmbus_xact_save_resp(xact, data, dlen);
407 do_wakeup = 1;
408 } else {
409 KASSERT(ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY,
410 ("no active xact pending"));
411 printf("vmbus: drop xact response\n");
412 }
413 mtx_unlock(&ctx->xc_lock);
414
415 if (do_wakeup)
416 wakeup(&ctx->xc_active);
417 }
418
419 void
vmbus_xact_ctx_wakeup(struct vmbus_xact_ctx * ctx,const void * data,size_t dlen)420 vmbus_xact_ctx_wakeup(struct vmbus_xact_ctx *ctx, const void *data, size_t dlen)
421 {
422 int do_wakeup = 0;
423
424 mtx_lock(&ctx->xc_lock);
425 /*
426 * NOTE:
427 * xc_active could be NULL, if the ctx has been orphaned.
428 */
429 if (ctx->xc_active != NULL) {
430 vmbus_xact_save_resp(ctx->xc_active, data, dlen);
431 do_wakeup = 1;
432 } else {
433 KASSERT(ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY,
434 ("no active xact pending"));
435 printf("vmbus: drop xact response\n");
436 }
437 mtx_unlock(&ctx->xc_lock);
438
439 if (do_wakeup)
440 wakeup(&ctx->xc_active);
441 }
442