sys/dev/vmware/vmci/vmci_datagram.c

   1 /*-
   2  * Copyright (c) 2018 VMware, Inc.
   3  *
   4  * SPDX-License-Identifier: (BSD-2-Clause OR GPL-2.0)
   5  */
   6
   7 /* This file implements the VMCI Simple Datagram API on the host. */
   8
   9 #include <sys/cdefs.h>
  10 __FBSDID("$FreeBSD$");
  11
  12 #include <sys/types.h>
  13 #include <sys/systm.h>
  14
  15 #include "vmci_datagram.h"
  16 #include "vmci_driver.h"
  17 #include "vmci_kernel_api.h"
  18 #include "vmci_kernel_defs.h"
  19 #include "vmci_resource.h"
  20
  21 #define LGPFX "vmci_datagram: "
  22
  23 /*
  24  * datagram_entry describes the datagram entity. It is used for datagram
  25  * entities created only on the host.
  26  */
  27 struct datagram_entry {
  28         struct vmci_resource    resource;
  29         uint32_t                flags;
  30         bool                    run_delayed;
  31         vmci_datagram_recv_cb   recv_cb;
  32         void                    *client_data;
  33         vmci_event              destroy_event;
  34         vmci_privilege_flags    priv_flags;
  35 };
  36
  37 struct vmci_delayed_datagram_info {
  38         struct datagram_entry   *entry;
  39         struct vmci_datagram    msg;
  40 };
  41
  42 static int      vmci_datagram_get_priv_flags_int(vmci_id contextID,
  43                     struct vmci_handle handle,
  44                     vmci_privilege_flags *priv_flags);
  45 static void     datagram_free_cb(void *resource);
  46 static int      datagram_release_cb(void *client_data);
  47
  48 /*------------------------------ Helper functions ----------------------------*/
  49
  50 /*
  51  *------------------------------------------------------------------------------
  52  *
  53  * datagram_free_cb --
  54  *
  55  *     Callback to free datagram structure when resource is no longer used,
  56  *     ie. the reference count reached 0.
  57  *
  58  * Result:
  59  *     None.
  60  *
  61  * Side effects:
  62  *     None.
  63  *
  64  *------------------------------------------------------------------------------
  65  */
  66
  67 static void
  68 datagram_free_cb(void *client_data)
  69 {
  70         struct datagram_entry *entry = (struct datagram_entry *)client_data;
  71
  72         ASSERT(entry);
  73
  74         vmci_signal_event(&entry->destroy_event);
  75
  76         /*
  77          * The entry is freed in vmci_datagram_destroy_hnd, who is waiting for
  78          * the above signal.
  79          */
  80 }
  81
  82 /*
  83  *------------------------------------------------------------------------------
  84  *
  85  * datagram_release_cb --
  86  *
  87  *     Callback to release the resource reference. It is called by the
  88  *     vmci_wait_on_event function before it blocks.
  89  *
  90  * Result:
  91  *     None.
  92  *
  93  * Side effects:
  94  *     None.
  95  *
  96  *------------------------------------------------------------------------------
  97  */
  98
  99 static int
 100 datagram_release_cb(void *client_data)
 101 {
 102         struct datagram_entry *entry;
 103
 104         entry = (struct datagram_entry *)client_data;
 105
 106         ASSERT(entry);
 107
 108         vmci_resource_release(&entry->resource);
 109
 110         return (0);
 111 }
 112
 113 /*
 114  *------------------------------------------------------------------------------
 115  *
 116  * datagram_create_hnd --
 117  *
 118  *     Internal function to create a datagram entry given a handle.
 119  *
 120  * Results:
 121  *     VMCI_SUCCESS if created, negative errno value otherwise.
 122  *
 123  * Side effects:
 124  *     None.
 125  *
 126  *------------------------------------------------------------------------------
 127  */
 128
 129 static int
 130 datagram_create_hnd(vmci_id resource_id, uint32_t flags,
 131     vmci_privilege_flags priv_flags, vmci_datagram_recv_cb recv_cb,
 132     void *client_data, struct vmci_handle *out_handle)
 133 {
 134         struct datagram_entry *entry;
 135         struct vmci_handle handle;
 136         vmci_id context_id;
 137         int result;
 138
 139         ASSERT(recv_cb != NULL);
 140         ASSERT(out_handle != NULL);
 141         ASSERT(!(priv_flags & ~VMCI_PRIVILEGE_ALL_FLAGS));
 142
 143         if ((flags & VMCI_FLAG_WELLKNOWN_DG_HND) != 0)
 144                 return (VMCI_ERROR_INVALID_ARGS);
 145         else {
 146                 if ((flags & VMCI_FLAG_ANYCID_DG_HND) != 0)
 147                         context_id = VMCI_INVALID_ID;
 148                 else {
 149                         context_id = vmci_get_context_id();
 150                         if (context_id == VMCI_INVALID_ID)
 151                                 return (VMCI_ERROR_NO_RESOURCES);
 152                 }
 153
 154                 if (resource_id == VMCI_INVALID_ID) {
 155                         resource_id = vmci_resource_get_id(context_id);
 156                         if (resource_id == VMCI_INVALID_ID)
 157                                 return (VMCI_ERROR_NO_HANDLE);
 158                 }
 159
 160                 handle = VMCI_MAKE_HANDLE(context_id, resource_id);
 161         }
 162
 163         entry = vmci_alloc_kernel_mem(sizeof(*entry), VMCI_MEMORY_NORMAL);
 164         if (entry == NULL) {
 165                 VMCI_LOG_WARNING(LGPFX"Failed allocating memory for datagram "
 166                     "entry.\n");
 167                 return (VMCI_ERROR_NO_MEM);
 168         }
 169
 170         if (!vmci_can_schedule_delayed_work()) {
 171                 if (flags & VMCI_FLAG_DG_DELAYED_CB) {
 172                         vmci_free_kernel_mem(entry, sizeof(*entry));
 173                         return (VMCI_ERROR_INVALID_ARGS);
 174                 }
 175                 entry->run_delayed = false;
 176         } else
 177                 entry->run_delayed = (flags & VMCI_FLAG_DG_DELAYED_CB) ?
 178                     true : false;
 179
 180         entry->flags = flags;
 181         entry->recv_cb = recv_cb;
 182         entry->client_data = client_data;
 183         vmci_create_event(&entry->destroy_event);
 184         entry->priv_flags = priv_flags;
 185
 186         /* Make datagram resource live. */
 187         result = vmci_resource_add(&entry->resource,
 188             VMCI_RESOURCE_TYPE_DATAGRAM, handle, datagram_free_cb, entry);
 189         if (result != VMCI_SUCCESS) {
 190                 VMCI_LOG_WARNING(LGPFX"Failed to add new resource "
 191                     "(handle=0x%x:0x%x).\n", handle.context, handle.resource);
 192                 vmci_destroy_event(&entry->destroy_event);
 193                 vmci_free_kernel_mem(entry, sizeof(*entry));
 194                 return (result);
 195         }
 196         *out_handle = handle;
 197
 198         return (VMCI_SUCCESS);
 199 }
 200
 201 /*------------------------------ Public API functions ------------------------*/
 202
 203 /*
 204  *------------------------------------------------------------------------------
 205  *
 206  * vmci_datagram_create_handle --
 207  *
 208  *     Creates a host context datagram endpoint and returns a handle to it.
 209  *
 210  * Results:
 211  *     VMCI_SUCCESS if created, negative errno value otherwise.
 212  *
 213  * Side effects:
 214  *     None.
 215  *
 216  *------------------------------------------------------------------------------
 217  */
 218
 219 int
 220 vmci_datagram_create_handle(vmci_id resource_id, uint32_t flags,
 221     vmci_datagram_recv_cb recv_cb, void *client_data,
 222     struct vmci_handle *out_handle)
 223 {
 224
 225         if (out_handle == NULL)
 226                 return (VMCI_ERROR_INVALID_ARGS);
 227
 228         if (recv_cb == NULL) {
 229                 VMCI_LOG_DEBUG(LGPFX"Client callback needed when creating "
 230                     "datagram.\n");
 231                 return (VMCI_ERROR_INVALID_ARGS);
 232         }
 233
 234         return (datagram_create_hnd(resource_id, flags,
 235             VMCI_DEFAULT_PROC_PRIVILEGE_FLAGS,
 236             recv_cb, client_data, out_handle));
 237 }
 238
 239 /*
 240  *------------------------------------------------------------------------------
 241  *
 242  * vmci_datagram_create_handle_priv --
 243  *
 244  *     Creates a host context datagram endpoint and returns a handle to it.
 245  *
 246  * Results:
 247  *     VMCI_SUCCESS if created, negative errno value otherwise.
 248  *
 249  * Side effects:
 250  *     None.
 251  *
 252  *------------------------------------------------------------------------------
 253  */
 254
 255 int
 256 vmci_datagram_create_handle_priv(vmci_id resource_id, uint32_t flags,
 257     vmci_privilege_flags priv_flags, vmci_datagram_recv_cb recv_cb,
 258     void *client_data, struct vmci_handle *out_handle)
 259 {
 260
 261         if (out_handle == NULL)
 262                 return (VMCI_ERROR_INVALID_ARGS);
 263
 264         if (recv_cb == NULL) {
 265                 VMCI_LOG_DEBUG(LGPFX"Client callback needed when creating "
 266                     "datagram.\n");
 267                 return (VMCI_ERROR_INVALID_ARGS);
 268         }
 269
 270         if (priv_flags & ~VMCI_PRIVILEGE_ALL_FLAGS)
 271                 return (VMCI_ERROR_INVALID_ARGS);
 272
 273         return (datagram_create_hnd(resource_id, flags, priv_flags, recv_cb,
 274             client_data, out_handle));
 275 }
 276
 277 /*
 278  *------------------------------------------------------------------------------
 279  *
 280  * vmci_datagram_destroy_handle --
 281  *
 282  *     Destroys a handle.
 283  *
 284  * Results:
 285  *     None.
 286  *
 287  * Side effects:
 288  *     None.
 289  *
 290  *------------------------------------------------------------------------------
 291  */
 292
 293 int
 294 vmci_datagram_destroy_handle(struct vmci_handle handle)
 295 {
 296         struct datagram_entry *entry;
 297         struct vmci_resource *resource;
 298
 299         resource = vmci_resource_get(handle,
 300             VMCI_RESOURCE_TYPE_DATAGRAM);
 301         if (resource == NULL) {
 302                 VMCI_LOG_DEBUG(LGPFX"Failed to destroy datagram "
 303                     "(handle=0x%x:0x%x).\n", handle.context, handle.resource);
 304                 return (VMCI_ERROR_NOT_FOUND);
 305         }
 306         entry = RESOURCE_CONTAINER(resource, struct datagram_entry, resource);
 307
 308         vmci_resource_remove(handle, VMCI_RESOURCE_TYPE_DATAGRAM);
 309
 310         /*
 311          * We now wait on the destroyEvent and release the reference we got
 312          * above.
 313          */
 314         vmci_wait_on_event(&entry->destroy_event, datagram_release_cb, entry);
 315
 316         /*
 317          * We know that we are now the only reference to the above entry so
 318          * can safely free it.
 319          */
 320         vmci_destroy_event(&entry->destroy_event);
 321         vmci_free_kernel_mem(entry, sizeof(*entry));
 322
 323         return (VMCI_SUCCESS);
 324 }
 325
 326 /*
 327  *------------------------------------------------------------------------------
 328  *
 329  *  vmci_datagram_get_priv_flags_int --
 330  *
 331  *      Internal utilility function with the same purpose as
 332  *      vmci_datagram_get_priv_flags that also takes a context_id.
 333  *
 334  *  Result:
 335  *      VMCI_SUCCESS on success, VMCI_ERROR_INVALID_ARGS if handle is invalid.
 336  *
 337  *  Side effects:
 338  *      None.
 339  *
 340  *------------------------------------------------------------------------------
 341  */
 342
 343 static int
 344 vmci_datagram_get_priv_flags_int(vmci_id context_id, struct vmci_handle handle,
 345     vmci_privilege_flags *priv_flags)
 346 {
 347
 348         ASSERT(priv_flags);
 349         ASSERT(context_id != VMCI_INVALID_ID);
 350
 351         if (context_id == VMCI_HOST_CONTEXT_ID) {
 352                 struct datagram_entry *src_entry;
 353                 struct vmci_resource *resource;
 354
 355                 resource = vmci_resource_get(handle,
 356                     VMCI_RESOURCE_TYPE_DATAGRAM);
 357                 if (resource == NULL)
 358                         return (VMCI_ERROR_INVALID_ARGS);
 359                 src_entry = RESOURCE_CONTAINER(resource, struct datagram_entry,
 360                     resource);
 361                 *priv_flags = src_entry->priv_flags;
 362                 vmci_resource_release(resource);
 363         } else if (context_id == VMCI_HYPERVISOR_CONTEXT_ID)
 364                 *priv_flags = VMCI_MAX_PRIVILEGE_FLAGS;
 365         else
 366                 *priv_flags = VMCI_NO_PRIVILEGE_FLAGS;
 367
 368         return (VMCI_SUCCESS);
 369 }
 370
 371 /*
 372  *------------------------------------------------------------------------------
 373  *
 374  *  vmci_datagram_fet_priv_flags --
 375  *
 376  *      Utility function that retrieves the privilege flags associated with a
 377  *      given datagram handle. For hypervisor and guest endpoints, the
 378  *      privileges are determined by the context ID, but for host endpoints
 379  *      privileges are associated with the complete handle.
 380  *
 381  *  Result:
 382  *      VMCI_SUCCESS on success, VMCI_ERROR_INVALID_ARGS if handle is invalid.
 383  *
 384  *  Side effects:
 385  *      None.
 386  *
 387  *------------------------------------------------------------------------------
 388  */
 389
 390 int
 391 vmci_datagram_get_priv_flags(struct vmci_handle handle,
 392     vmci_privilege_flags *priv_flags)
 393 {
 394
 395         if (priv_flags == NULL || handle.context == VMCI_INVALID_ID)
 396                 return (VMCI_ERROR_INVALID_ARGS);
 397
 398         return (vmci_datagram_get_priv_flags_int(handle.context, handle,
 399             priv_flags));
 400 }
 401
 402 /*
 403  *------------------------------------------------------------------------------
 404  *
 405  * vmci_datagram_delayed_dispatch_cb --
 406  *
 407  *     Calls the specified callback in a delayed context.
 408  *
 409  * Results:
 410  *     None.
 411  *
 412  * Side effects:
 413  *     None.
 414  *
 415  *------------------------------------------------------------------------------
 416  */
 417
 418 static void
 419 vmci_datagram_delayed_dispatch_cb(void *data)
 420 {
 421         struct vmci_delayed_datagram_info *dg_info;
 422
 423         dg_info = (struct vmci_delayed_datagram_info *)data;
 424
 425         ASSERT(data);
 426
 427         dg_info->entry->recv_cb(dg_info->entry->client_data, &dg_info->msg);
 428
 429         vmci_resource_release(&dg_info->entry->resource);
 430
 431         vmci_free_kernel_mem(dg_info, sizeof(*dg_info) +
 432             (size_t)dg_info->msg.payload_size);
 433 }
 434
 435 /*
 436  *------------------------------------------------------------------------------
 437  *
 438  * vmci_datagram_dispatch_as_guest --
 439  *
 440  *     Dispatch datagram as a guest, down through the VMX and potentially to
 441  *     the host.
 442  *
 443  * Result:
 444  *     Number of bytes sent on success, appropriate error code otherwise.
 445  *
 446  * Side effects:
 447  *     None.
 448  *
 449  *------------------------------------------------------------------------------
 450  */
 451
 452 static int
 453 vmci_datagram_dispatch_as_guest(struct vmci_datagram *dg)
 454 {
 455         struct vmci_resource *resource;
 456         int retval;
 457
 458         resource = vmci_resource_get(dg->src, VMCI_RESOURCE_TYPE_DATAGRAM);
 459         if (NULL == resource)
 460                 return VMCI_ERROR_NO_HANDLE;
 461
 462         retval = vmci_send_datagram(dg);
 463         vmci_resource_release(resource);
 464
 465         return (retval);
 466 }
 467
 468 /*
 469  *------------------------------------------------------------------------------
 470  *
 471  * vmci_datagram_dispatch --
 472  *
 473  *     Dispatch datagram. This will determine the routing for the datagram and
 474  *     dispatch it accordingly.
 475  *
 476  * Result:
 477  *     Number of bytes sent on success, appropriate error code otherwise.
 478  *
 479  * Side effects:
 480  *     None.
 481  *
 482  *------------------------------------------------------------------------------
 483  */
 484
 485 int
 486 vmci_datagram_dispatch(vmci_id context_id, struct vmci_datagram *dg)
 487 {
 488
 489         ASSERT(dg);
 490         ASSERT_ON_COMPILE(sizeof(struct vmci_datagram) == 24);
 491
 492         if (VMCI_DG_SIZE(dg) > VMCI_MAX_DG_SIZE) {
 493                 VMCI_LOG_DEBUG(LGPFX"Payload (size=%lu bytes) too big to send."
 494                     "\n", dg->payload_size);
 495                 return (VMCI_ERROR_INVALID_ARGS);
 496         }
 497
 498         return (vmci_datagram_dispatch_as_guest(dg));
 499 }
 500
 501 /*
 502  *------------------------------------------------------------------------------
 503  *
 504  * vmci_datagram_invoke_guest_handler --
 505  *
 506  *     Invoke the handler for the given datagram. This is intended to be called
 507  *     only when acting as a guest and receiving a datagram from the virtual
 508  *     device.
 509  *
 510  * Result:
 511  *     VMCI_SUCCESS on success, other error values on failure.
 512  *
 513  * Side effects:
 514  *     None.
 515  *
 516  *------------------------------------------------------------------------------
 517  */
 518
 519 int
 520 vmci_datagram_invoke_guest_handler(struct vmci_datagram *dg)
 521 {
 522         struct datagram_entry *dst_entry;
 523         struct vmci_resource *resource;
 524         int retval;
 525
 526         ASSERT(dg);
 527
 528         if (dg->payload_size > VMCI_MAX_DG_PAYLOAD_SIZE) {
 529                 VMCI_LOG_DEBUG(LGPFX"Payload (size=%lu bytes) too large to "
 530                     "deliver.\n", dg->payload_size);
 531                 return (VMCI_ERROR_PAYLOAD_TOO_LARGE);
 532         }
 533
 534         resource = vmci_resource_get(dg->dst, VMCI_RESOURCE_TYPE_DATAGRAM);
 535         if (NULL == resource) {
 536                 VMCI_LOG_DEBUG(LGPFX"destination (handle=0x%x:0x%x) doesn't "
 537                     "exist.\n", dg->dst.context, dg->dst.resource);
 538                 return (VMCI_ERROR_NO_HANDLE);
 539         }
 540
 541         dst_entry = RESOURCE_CONTAINER(resource, struct datagram_entry,
 542             resource);
 543         if (dst_entry->run_delayed) {
 544                 struct vmci_delayed_datagram_info *dg_info;
 545
 546                 dg_info = vmci_alloc_kernel_mem(sizeof(*dg_info) +
 547                     (size_t)dg->payload_size, VMCI_MEMORY_ATOMIC);
 548                 if (NULL == dg_info) {
 549                         vmci_resource_release(resource);
 550                         retval = VMCI_ERROR_NO_MEM;
 551                         goto exit;
 552                 }
 553
 554                 dg_info->entry = dst_entry;
 555                 memcpy(&dg_info->msg, dg, VMCI_DG_SIZE(dg));
 556
 557                 retval = vmci_schedule_delayed_work(
 558                     vmci_datagram_delayed_dispatch_cb, dg_info);
 559                 if (retval < VMCI_SUCCESS) {
 560                         VMCI_LOG_WARNING(LGPFX"Failed to schedule delayed "
 561                             "work for datagram (result=%d).\n", retval);
 562                         vmci_free_kernel_mem(dg_info, sizeof(*dg_info) +
 563                             (size_t)dg->payload_size);
 564                         vmci_resource_release(resource);
 565                         dg_info = NULL;
 566                         goto exit;
 567                 }
 568         } else {
 569                 dst_entry->recv_cb(dst_entry->client_data, dg);
 570                 vmci_resource_release(resource);
 571                 retval = VMCI_SUCCESS;
 572         }
 573
 574 exit:
 575         return (retval);
 576 }
 577
 578 /*
 579  *------------------------------------------------------------------------------
 580  *
 581  * vmci_datagram_send --
 582  *
 583  *     Sends the payload to the destination datagram handle.
 584  *
 585  * Results:
 586  *     Returns number of bytes sent if success, or error code if failure.
 587  *
 588  * Side effects:
 589  *     None.
 590  *
 591  *------------------------------------------------------------------------------
 592  */
 593
 594 int
 595 vmci_datagram_send(struct vmci_datagram *msg)
 596 {
 597
 598         if (msg == NULL)
 599                 return (VMCI_ERROR_INVALID_ARGS);
 600
 601         return (vmci_datagram_dispatch(VMCI_INVALID_ID, msg));
 602 }
 603
 604 /*
 605  *------------------------------------------------------------------------------
 606  *
 607  * vmci_datagram_sync --
 608  *
 609  *     Use this as a synchronization point when setting globals, for example,
 610  *     during device shutdown.
 611  *
 612  * Results:
 613  *     None.
 614  *
 615  * Side effects:
 616  *     None.
 617  *
 618  *------------------------------------------------------------------------------
 619  */
 620
 621 void
 622 vmci_datagram_sync(void)
 623 {
 624
 625         vmci_resource_sync();
 626 }
 627
 628 /*
 629  *------------------------------------------------------------------------------
 630  *
 631  * vmci_datagram_check_host_capabilities --
 632  *
 633  *     Verify that the host supports the resources we need. None are required
 634  *     for datagrams since they are implicitly supported.
 635  *
 636  * Results:
 637  *     true.
 638  *
 639  * Side effects:
 640  *     None.
 641  *
 642  *------------------------------------------------------------------------------
 643  */
 644
 645 bool
 646 vmci_datagram_check_host_capabilities(void)
 647 {
 648
 649         return (true);
 650 }