sys/dev/hyperv/vmbus/vmbus_xact.c

   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/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/lock.h>
  32 #include <sys/malloc.h>
  33 #include <sys/mutex.h>
  34 #include <sys/proc.h>
  35 #include <sys/systm.h>
  36
  37 #include <dev/hyperv/include/hyperv_busdma.h>
  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         struct hyperv_dma               x_req_dma;
  46
  47         const void                      *x_resp;
  48         size_t                          x_resp_len;
  49         void                            *x_resp0;
  50 };
  51
  52 struct vmbus_xact_ctx {
  53         size_t                          xc_req_size;
  54         size_t                          xc_resp_size;
  55         size_t                          xc_priv_size;
  56
  57         struct mtx                      xc_lock;
  58         /*
  59          * Protected by xc_lock.
  60          */
  61         uint32_t                        xc_flags;       /* VMBUS_XACT_CTXF_ */
  62         struct vmbus_xact               *xc_free;
  63         struct vmbus_xact               *xc_active;
  64         struct vmbus_xact               *xc_orphan;
  65 };
  66
  67 #define VMBUS_XACT_CTXF_DESTROY         0x0001
  68
  69 static struct vmbus_xact        *vmbus_xact_alloc(struct vmbus_xact_ctx *,
  70                                     bus_dma_tag_t);
  71 static void                     vmbus_xact_free(struct vmbus_xact *);
  72 static struct vmbus_xact        *vmbus_xact_get1(struct vmbus_xact_ctx *,
  73                                     uint32_t);
  74 static const void               *vmbus_xact_wait1(struct vmbus_xact *, size_t *,
  75                                     bool);
  76 static const void               *vmbus_xact_return(struct vmbus_xact *,
  77                                     size_t *);
  78 static void                     vmbus_xact_save_resp(struct vmbus_xact *,
  79                                     const void *, size_t);
  80 static void                     vmbus_xact_ctx_free(struct vmbus_xact_ctx *);
  81
  82 static struct vmbus_xact *
  83 vmbus_xact_alloc(struct vmbus_xact_ctx *ctx, bus_dma_tag_t parent_dtag)
  84 {
  85         struct vmbus_xact *xact;
  86
  87         xact = malloc(sizeof(*xact), M_DEVBUF, M_WAITOK | M_ZERO);
  88         xact->x_ctx = ctx;
  89
  90         /* XXX assume that page aligned is enough */
  91         xact->x_req = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,
  92             ctx->xc_req_size, &xact->x_req_dma, BUS_DMA_WAITOK);
  93         if (xact->x_req == NULL) {
  94                 free(xact, M_DEVBUF);
  95                 return (NULL);
  96         }
  97         if (ctx->xc_priv_size != 0)
  98                 xact->x_priv = malloc(ctx->xc_priv_size, M_DEVBUF, M_WAITOK);
  99         xact->x_resp0 = malloc(ctx->xc_resp_size, M_DEVBUF, M_WAITOK);
 100
 101         return (xact);
 102 }
 103
 104 static void
 105 vmbus_xact_free(struct vmbus_xact *xact)
 106 {
 107
 108         hyperv_dmamem_free(&xact->x_req_dma, xact->x_req);
 109         free(xact->x_resp0, M_DEVBUF);
 110         if (xact->x_priv != NULL)
 111                 free(xact->x_priv, M_DEVBUF);
 112         free(xact, M_DEVBUF);
 113 }
 114
 115 static struct vmbus_xact *
 116 vmbus_xact_get1(struct vmbus_xact_ctx *ctx, uint32_t dtor_flag)
 117 {
 118         struct vmbus_xact *xact;
 119
 120         mtx_lock(&ctx->xc_lock);
 121
 122         while ((ctx->xc_flags & dtor_flag) == 0 && ctx->xc_free == NULL)
 123                 mtx_sleep(&ctx->xc_free, &ctx->xc_lock, 0, "gxact", 0);
 124         if (ctx->xc_flags & dtor_flag) {
 125                 /* Being destroyed */
 126                 xact = NULL;
 127         } else {
 128                 xact = ctx->xc_free;
 129                 KASSERT(xact != NULL, ("no free xact"));
 130                 KASSERT(xact->x_resp == NULL, ("xact has pending response"));
 131                 ctx->xc_free = NULL;
 132         }
 133
 134         mtx_unlock(&ctx->xc_lock);
 135
 136         return (xact);
 137 }
 138
 139 struct vmbus_xact_ctx *
 140 vmbus_xact_ctx_create(bus_dma_tag_t dtag, size_t req_size, size_t resp_size,
 141     size_t priv_size)
 142 {
 143         struct vmbus_xact_ctx *ctx;
 144
 145         KASSERT(req_size > 0, ("request size is 0"));
 146         KASSERT(resp_size > 0, ("response size is 0"));
 147
 148         ctx = malloc(sizeof(*ctx), M_DEVBUF, M_WAITOK | M_ZERO);
 149         ctx->xc_req_size = req_size;
 150         ctx->xc_resp_size = resp_size;
 151         ctx->xc_priv_size = priv_size;
 152
 153         ctx->xc_free = vmbus_xact_alloc(ctx, dtag);
 154         if (ctx->xc_free == NULL) {
 155                 free(ctx, M_DEVBUF);
 156                 return (NULL);
 157         }
 158
 159         mtx_init(&ctx->xc_lock, "vmbus xact", NULL, MTX_DEF);
 160
 161         return (ctx);
 162 }
 163
 164 bool
 165 vmbus_xact_ctx_orphan(struct vmbus_xact_ctx *ctx)
 166 {
 167         mtx_lock(&ctx->xc_lock);
 168         if (ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) {
 169                 mtx_unlock(&ctx->xc_lock);
 170                 return (false);
 171         }
 172         ctx->xc_flags |= VMBUS_XACT_CTXF_DESTROY;
 173         mtx_unlock(&ctx->xc_lock);
 174
 175         wakeup(&ctx->xc_free);
 176         wakeup(&ctx->xc_active);
 177
 178         ctx->xc_orphan = vmbus_xact_get1(ctx, 0);
 179         if (ctx->xc_orphan == NULL)
 180                 panic("can't get xact");
 181         return (true);
 182 }
 183
 184 static void
 185 vmbus_xact_ctx_free(struct vmbus_xact_ctx *ctx)
 186 {
 187         KASSERT(ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY,
 188             ("xact ctx was not orphaned"));
 189         KASSERT(ctx->xc_orphan != NULL, ("no orphaned xact"));
 190
 191         vmbus_xact_free(ctx->xc_orphan);
 192         mtx_destroy(&ctx->xc_lock);
 193         free(ctx, M_DEVBUF);
 194 }
 195
 196 void
 197 vmbus_xact_ctx_destroy(struct vmbus_xact_ctx *ctx)
 198 {
 199
 200         vmbus_xact_ctx_orphan(ctx);
 201         vmbus_xact_ctx_free(ctx);
 202 }
 203
 204 struct vmbus_xact *
 205 vmbus_xact_get(struct vmbus_xact_ctx *ctx, size_t req_len)
 206 {
 207         struct vmbus_xact *xact;
 208
 209         if (req_len > ctx->xc_req_size)
 210                 panic("invalid request size %zu", req_len);
 211
 212         xact = vmbus_xact_get1(ctx, VMBUS_XACT_CTXF_DESTROY);
 213         if (xact == NULL)
 214                 return (NULL);
 215
 216         memset(xact->x_req, 0, req_len);
 217         return (xact);
 218 }
 219
 220 void
 221 vmbus_xact_put(struct vmbus_xact *xact)
 222 {
 223         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 224
 225         KASSERT(ctx->xc_active == NULL, ("pending active xact"));
 226         xact->x_resp = NULL;
 227
 228         mtx_lock(&ctx->xc_lock);
 229         KASSERT(ctx->xc_free == NULL, ("has free xact"));
 230         ctx->xc_free = xact;
 231         mtx_unlock(&ctx->xc_lock);
 232         wakeup(&ctx->xc_free);
 233 }
 234
 235 void *
 236 vmbus_xact_req_data(const struct vmbus_xact *xact)
 237 {
 238
 239         return (xact->x_req);
 240 }
 241
 242 bus_addr_t
 243 vmbus_xact_req_paddr(const struct vmbus_xact *xact)
 244 {
 245
 246         return (xact->x_req_dma.hv_paddr);
 247 }
 248
 249 void *
 250 vmbus_xact_priv(const struct vmbus_xact *xact, size_t priv_len)
 251 {
 252
 253         if (priv_len > xact->x_ctx->xc_priv_size)
 254                 panic("invalid priv size %zu", priv_len);
 255         return (xact->x_priv);
 256 }
 257
 258 void
 259 vmbus_xact_activate(struct vmbus_xact *xact)
 260 {
 261         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 262
 263         KASSERT(xact->x_resp == NULL, ("xact has pending response"));
 264
 265         mtx_lock(&ctx->xc_lock);
 266         KASSERT(ctx->xc_active == NULL, ("pending active xact"));
 267         ctx->xc_active = xact;
 268         mtx_unlock(&ctx->xc_lock);
 269 }
 270
 271 void
 272 vmbus_xact_deactivate(struct vmbus_xact *xact)
 273 {
 274         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 275
 276         mtx_lock(&ctx->xc_lock);
 277         KASSERT(ctx->xc_active == xact, ("xact mismatch"));
 278         ctx->xc_active = NULL;
 279         mtx_unlock(&ctx->xc_lock);
 280 }
 281
 282 static const void *
 283 vmbus_xact_return(struct vmbus_xact *xact, size_t *resp_len)
 284 {
 285         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 286         const void *resp;
 287
 288         mtx_assert(&ctx->xc_lock, MA_OWNED);
 289         KASSERT(ctx->xc_active == xact, ("xact trashed"));
 290
 291         if ((ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) && xact->x_resp == NULL) {
 292                 uint8_t b = 0;
 293
 294                 /*
 295                  * Orphaned and no response was received yet; fake up
 296                  * an one byte response.
 297                  */
 298                 printf("vmbus: xact ctx was orphaned w/ pending xact\n");
 299                 vmbus_xact_save_resp(ctx->xc_active, &b, sizeof(b));
 300         }
 301         KASSERT(xact->x_resp != NULL, ("no response"));
 302
 303         ctx->xc_active = NULL;
 304
 305         resp = xact->x_resp;
 306         *resp_len = xact->x_resp_len;
 307
 308         return (resp);
 309 }
 310
 311 static const void *
 312 vmbus_xact_wait1(struct vmbus_xact *xact, size_t *resp_len,
 313     bool can_sleep)
 314 {
 315         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 316         const void *resp;
 317
 318         mtx_lock(&ctx->xc_lock);
 319
 320         KASSERT(ctx->xc_active == xact, ("xact mismatch"));
 321         while (xact->x_resp == NULL &&
 322             (ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) == 0) {
 323                 if (can_sleep) {
 324                         mtx_sleep(&ctx->xc_active, &ctx->xc_lock, 0,
 325                             "wxact", 0);
 326                 } else {
 327                         mtx_unlock(&ctx->xc_lock);
 328                         DELAY(1000);
 329                         mtx_lock(&ctx->xc_lock);
 330                 }
 331         }
 332         resp = vmbus_xact_return(xact, resp_len);
 333
 334         mtx_unlock(&ctx->xc_lock);
 335
 336         return (resp);
 337 }
 338
 339 const void *
 340 vmbus_xact_wait(struct vmbus_xact *xact, size_t *resp_len)
 341 {
 342
 343         return (vmbus_xact_wait1(xact, resp_len, true /* can sleep */));
 344 }
 345
 346 const void *
 347 vmbus_xact_busywait(struct vmbus_xact *xact, size_t *resp_len)
 348 {
 349
 350         return (vmbus_xact_wait1(xact, resp_len, false /* can't sleep */));
 351 }
 352
 353 const void *
 354 vmbus_xact_poll(struct vmbus_xact *xact, size_t *resp_len)
 355 {
 356         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 357         const void *resp;
 358
 359         mtx_lock(&ctx->xc_lock);
 360
 361         KASSERT(ctx->xc_active == xact, ("xact mismatch"));
 362         if (xact->x_resp == NULL &&
 363             (ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY) == 0) {
 364                 mtx_unlock(&ctx->xc_lock);
 365                 *resp_len = 0;
 366                 return (NULL);
 367         }
 368         resp = vmbus_xact_return(xact, resp_len);
 369
 370         mtx_unlock(&ctx->xc_lock);
 371
 372         return (resp);
 373 }
 374
 375 static void
 376 vmbus_xact_save_resp(struct vmbus_xact *xact, const void *data, size_t dlen)
 377 {
 378         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 379         size_t cplen = dlen;
 380
 381         mtx_assert(&ctx->xc_lock, MA_OWNED);
 382
 383         if (cplen > ctx->xc_resp_size) {
 384                 printf("vmbus: xact response truncated %zu -> %zu\n",
 385                     cplen, ctx->xc_resp_size);
 386                 cplen = ctx->xc_resp_size;
 387         }
 388
 389         KASSERT(ctx->xc_active == xact, ("xact mismatch"));
 390         memcpy(xact->x_resp0, data, cplen);
 391         xact->x_resp_len = cplen;
 392         xact->x_resp = xact->x_resp0;
 393 }
 394
 395 void
 396 vmbus_xact_wakeup(struct vmbus_xact *xact, const void *data, size_t dlen)
 397 {
 398         struct vmbus_xact_ctx *ctx = xact->x_ctx;
 399         int do_wakeup = 0;
 400
 401         mtx_lock(&ctx->xc_lock);
 402         /*
 403          * NOTE:
 404          * xc_active could be NULL, if the ctx has been orphaned.
 405          */
 406         if (ctx->xc_active != NULL) {
 407                 vmbus_xact_save_resp(xact, data, dlen);
 408                 do_wakeup = 1;
 409         } else {
 410                 KASSERT(ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY,
 411                     ("no active xact pending"));
 412                 printf("vmbus: drop xact response\n");
 413         }
 414         mtx_unlock(&ctx->xc_lock);
 415
 416         if (do_wakeup)
 417                 wakeup(&ctx->xc_active);
 418 }
 419
 420 void
 421 vmbus_xact_ctx_wakeup(struct vmbus_xact_ctx *ctx, const void *data, size_t dlen)
 422 {
 423         int do_wakeup = 0;
 424
 425         mtx_lock(&ctx->xc_lock);
 426         /*
 427          * NOTE:
 428          * xc_active could be NULL, if the ctx has been orphaned.
 429          */
 430         if (ctx->xc_active != NULL) {
 431                 vmbus_xact_save_resp(ctx->xc_active, data, dlen);
 432                 do_wakeup = 1;
 433         } else {
 434                 KASSERT(ctx->xc_flags & VMBUS_XACT_CTXF_DESTROY,
 435                     ("no active xact pending"));
 436                 printf("vmbus: drop xact response\n");
 437         }
 438         mtx_unlock(&ctx->xc_lock);
 439
 440         if (do_wakeup)
 441                 wakeup(&ctx->xc_active);
 442 }