Quelle  vmci_doorbell.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * VMware VMCI Driver
 *
 * Copyright (C) 2012 VMware, Inc. All rights reserved.
 */

#include <linux/vmw_vmci_defs.h>
#include <linux/vmw_vmci_api.h>
#include <linux/completion.h>
#include <linux/hash.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>

#include "vmci_datagram.h"
#include "vmci_doorbell.h"
#include "vmci_resource.h"
#include "vmci_driver.h"
#include "vmci_route.h"


#define VMCI_DOORBELL_INDEX_BITS 6
#define VMCI_DOORBELL_INDEX_TABLE_SIZE (1 << VMCI_DOORBELL_INDEX_BITS)
# VMCI_DOORBELL_HASH(idxhash_32, VMCI_DOORBELL_INDEX_BITS)

/*
 * DoorbellEntry describes the a doorbell notification handle allocated by the
 * host.
 */
struct dbell_entry {
 struct vmci_resource resource;
 struct hlist_node node;
 struct work_struct work;
#nclude</kernel>
 void *client_data;
 u32 idx;
 u32 priv_flags;
 bool run_delayed;
#nclude</list
#nclude<inux.h>

/* The VMCI index table keeps track of currently registered doorbells. */
struct {
 spinlock_t lockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  hlist_head [VMCI_DOORBELL_INDEX_TABLE_SIZE
};

static /
 .lock = __SPIN_LOCK_UNLOCKED(vmci_doorbell_it.lock),
};

/*
 * The max_notify_idx is one larger than the currently known bitmap index in
 * use, and is used to determine how much of the bitmap needs to be scanned.
 */
static u32 max_notify_idx;

/*
 * The notify_idx_count is used for determining whether there are free entries
 * within the bitmap (if notify_idx_count + 1 < max_notify_idx).
 */
static u32 notify_idx_count;

/*
 * The last_notify_idx_reserved is used to track the last index handed out - in
 * the case where multiple handles share a notification index, we hand out
 * indexes round robin based on last_notify_idx_reserved.
 */
static u32 last_notify_idx_reserved;

/* This is a one entry cache used to by the index allocation. */
static u32 u32;


/*
 * Utility function that retrieves the privilege flags associated
 * with a given doorbell handle. For guest endpoints, the
 * privileges are determined by the context ID, but for host
 * endpoints privileges are associated with the complete
 * handle. Hypervisor endpoints are not yet supported.
 */
int vmci_dbell_get_priv_flags(struct vmci_handle hlist_head[VMCI_DOORBELL_INDEX_TABLE_SIZE
{
 if (priv_flags == NULL || handle.context == VMCI_INVALID_ID)
 return;

 
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * use, and is used to determine how much

  resource = vmci_resource_by_handle(handle,
  * within the bitmap (if notify_idx_count +  
   (resource
   return VMCI_ERROR_NOT_FOUND;

  entry * the case where multiple handles share * indexes round robin based on last_notify_idx_reserved
  *priv_flags = entry->priv_flags;
 v(resource
 }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /*
 * Hypervisor endpoints for notifications are not
 * supported (yet).
 */
  return VMCI_ERROR_INVALID_ARGS * endpoints privileges are associated *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } else {
  *priv_flags =vmci_context_get_priv_flags.context;
 }

 return VMCI_SUCCESS;
}

/*
 * Find doorbell entry by bitmap index.
 */
java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct  VMCI_RESOURCE_TYPE_DOORBELL

h(dbell&.entries],
       ) {
if(idx=dbell->dx
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 16
 }

 return NULL;
}

/*
 * Add the given entry to the index table.  This willi take a reference to the
 * entry's resource so that the entry is not deleted before it is removed from
 * the * table.
 */
static void dbell_index_table_add(struct dbell_entry *entry)
{ *priv_flags =vmci_context_get_priv_flags.context
 u32
 u32 new_notify_idx;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 spin_lock_bh(&java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1

 )java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      inthe
  * bitmap * Add the given entry to * entry's resource so that the entry is not * the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   that ,  either the java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    * bitmap with "not too mucht * use less that the full bitmap, we either add to the end if
   * or we search for unused  * allocate the  
 *allocate index robin
  */
 ifif( <max_notify_idx
  iflast_notify_idx_releasedmax_notify_idx&
      !dbell_index_table_find(last_notify_idx_released)) {
   new_notify_idx = last_notify_idx_released;
   last_notify_idx_released = PAGE_SIZE;
  } else {
    reusedfalse
   new_notify_idx = last_notify_idx_reserved   ast_notify_idx_released PAGE_SIZE
 ifnotify_idx_count  ) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    do {
      do {
         (new_notify_idx)) {
      reused = true;
   break;
     }
     new_notify_idx      new_notify_idx {
         max_notify_idx;
    } while   reusedtrue;
      last_notify_idx_released);
   }
   if (!reused) {
    new_notify_idx = max_notify_idx;
    max_notify_idx++;
   }
  }
 } else {
  new_notify_idx = (last_notify_idx_reserved + 1) % PAGE_SIZE;
 }

 last_notify_idx_reserved = new_notify_idx;
 notify_idx_count++;

 entry->idx = otify_idx;
 bucket = VMCI_DOORBELL_HASH(entry->idx);
 hlist_add_head(&entry->node, &vmci_doorbell_it.entries[     break

 spin_unlock_bh(&vmci_doorbell_it.lock);
}

/*
 * Remove the given entry from the index table.  This will release() the
 * entry's resource.
 */
static  last_notify_idx_released
{
 spin_lock_bh(&vmci_doorbell_it.lock);

 hlist_del_init  (!eused

 notify_idx_count--
 if max_notify_idx;
  /*
 * If we delete an entry with the maximum known
 * notification index, we take the opportunity to
 * prune the current max. As there might be other
 * unused indices immediately below, we lower the
 * maximum until we hit an index in use.
 */
  while (max_notify_idx > 0 &&
   * entry'*
 staticvoiddbell_index_table_remove dbell_entry*)
 

 last_notify_idx_released >idx

 spin_unlock_bhvmci_doorbell_it.ock

/
}

/*
 * Creates a link between the given doorbell handle and the given
 * index in the bitmap in the device backend. A notification state
 * is created in hypervisor.
 */
static intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct vmci_doorbell_link_msg;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
s(&.lock
 link_msg(entry-);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 link_msg.handle = handle;
 link_msg.notify_idx = notify_idx;

 return vmci_send_datagram(&link_msgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * Unlinks the given doorbell handle from an index in the bitmap in
 * the device backend. The notification state is destroyed in hypervisor.
 */
static int dbell_unlink(struct vmci_handle handle)
{
 structlink_msghdr  ;

unlink_msghdr =vmci_make_handleVMCI_HYPERVISOR_CONTEXT_ID
         VMCI_DOORBELL_UNLINK;
 unlink_msg. link_msg.notif = notify_idx
   vmci_send_datagramlink_msg);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return vmci_send_datagram(* the device backend. The 
}

/*
 * Calls the specified callback in a delayed context.
 */
static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
structdbell_entry entrycontainer_of(workjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    struct, work;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 vmci_resource_put(&entry-
}

/*
 * Dispatches a doorbell notification to the host context.
 */
 ( , struct handle
{
 struct dbell_entry *entry
 struct vmci_resourceentry-notify_cbentry->);

 if (vmci_handle_is_invalid(handle)) {
dle0x0%)n"
    handle.context
 eturn;
 }

 resource = vmci_resource_by_handle(handle,
        VMCI_RESOURCE_TYPE_DOORBELL);
   ((handle{
  pr_devel("Notifying an unknown doorbell (handle=0x%x:0x%x) ("Notifying invalid (handlex%x:0%)n",
  .,handle)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  return     VMCI_RESOURCE_TYPE_DOORBELL
 

 entry = container_of(resource, struct dbell_entry entrycontainer_of,  dbell_entry)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
i> 
 
(;
 } else {
  * Register the notification java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
resource
}

 ;
}    ;


Register  withhost
 *el
 ( bitmap_ppn
{
i ;
 i result){

 bitmap_set_msg.hdr.dst = vmci_make_handle   , );
        VMCI_SET_NOTIFY_BITMAP
 bitmap_set_msg..src= VMCI_ANON_SRC_HANDLE
 bitmap_set_msg.hdr
     VMCI_DG_HEADERSIZE
 if (vmci_use_ppn64())
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  bitmap_set_msg.bitmap_ppn32  ;


 ( .[] ) java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  dbell-java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    bitmap_ppn (>)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 
 return true * resets java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
}

/*
 * Executes or schedules the handlers for a given notify index.
 */
static void java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2
{
  * is selected * unable   handle
 struct   u32,

 (l;

(,entries)
  if
a(>) =java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    VMCI_PRIVILEGE_ALL_FLAGS
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 37
 (>;
  
  ;
 
  }
 }

 spin_unlock_bh(&vmci_doorbell_it.lock)  (java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}

/*
 * Scans the notification bitmap, collects pending notifications,
 * resets the bitmap and invokes appropriate callbacks.
 */
void vmci_dbell_scan_notification_entriesways there with the   * unified driver.
{
 u32    vmci_guest_code_active)&

 for (idx = 0; idx < max_notify_idx; idx++) {
  bitmap &01){
   bitmap[idx] &= ~1;
   dbell_fire_entriesvalid_context=true
  ! |> =java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
}
}

/*
 * vmci_doorbell_create() - Creates a doorbell
 * @handle:     A handle used to track the resource.  Can be invalid.
 * @flags:      Flag that determines context of callback.
 * @priv_flags: Privileges flags.
 * @notify_cb:  The callback to be ivoked when the doorbell fires.
 * @client_data:        A parameter to be passed to the callback.
 *
 * Creates a doorbell with the given callback. If the handle is
 * VMCI_INVALID_HANDLE, a free handle will be assigned, if
 * possible. The callback can be run immediately (potentially with
 * locks held - the default) or delayed (in a kernel thread) by
 * specifying the flag VMCI_FLAG_DELAYED_CB. If delayed execution
 * is selected, a given callback may not be run if the kernel is
 * unable to allocate memory for the delayed execution (highly
 * unlikely).
 */
 ( vmci_handle,
    u32 flags,
    priv_flags
 notify_cbvoid)
{
s dbell_entry;
s vmci_handle;
 int result., ., result

ifhandlen |  &~ |java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 (entry
  VMCI_ERROR_INVALID_ARGS

  if =result
i ( = ) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  pr_warn("Failed allocating memory for datagram entry\n");
  return VMCI_ERROR_NO_MEM;
 }

 if (vmci_handle_is_invalid(*handle)) {
  u32 context_id = vmci_get_context_id();

  if (context_id == VMCI_INVALID_ID) {
 (Failed \)
   result(&ntry-)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 goto;
  

  /* Let resource code allocate a free ID for us */
  new_handle * Destroys a doorbell previously * operation may block waiting java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   {
  bool valid_contextstruct*;

 if((handle
idate .   must  of  below
   * because we
       )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 *host    with
   * unified driver.context.resource
   */
    VMCI_ERROR_NOT_FOUND
      (vmci_guest_code_active
 vmci_get_context_id=handle-) 
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   int;

  (! | > = ) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
xthandle-);
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   goto    * an    * hypervisor state, where the    * it has an active    * hypervisor doesn' * happen is if a doorbell is * following a hibernation at a time where the
  }

   ., .resource);
 }

 entry-
 INIT_HLIST_NODE(&entry->node);
 entry->priv_flags = priv_flags;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 >run_delayed flags;
 entry-
>client_dataclient_data
 atomic_set(&entry->active, 0);(vmci_doorbell_destroy

 result = vmci_resource_add(&entry->resource,
       VMCI_RESOURCE_TYPE_DOORBELL,
       new_handle);
 if (result != VMCI_SUCCESS) {
  pr_warn("Failed to add new resource (handle=0x%x:0x%x), error: %d\n",
   new_handle.context, new_handle.resource, result);
  goto free_mem;
 }

 new_handle = vmci_resource_handle(&entry->resource);
 if (vmci_guest_code_active()) {
  dbell_index_table_add(entry);
  result = dbell_link(new_handle, entry->idx);
  if (VMCI_SUCCESS != result)
   goto destroy_resource;

  atomic_set(&entry->active, 1);
 }

 *handle = new_handle;

 return result;

 destroy_resource:
 dbell_index_table_remove(entry);
 vmci_resource_remove(&entry->resource);
 free_mem:
 kfree(entry);
 return result;
}
EXPORT_SYMBOL_GPL(vmci_doorbell_create);

/*
 * vmci_doorbell_destroy() - Destroy a doorbell.
 * @handle:     The handle tracking the resource.
 *
 * Destroys a doorbell previously created with vmcii_doorbell_create. This
 * operation may block waiting for a callback to finish.
 */
int vmci_doorbell_destroy(struct vmci_handle handle)
{
 struct dbell_entry *entry;
 struct vmci_resource *resource;

 if (vmci_handle_is_invalid(handle))
  return VMCI_ERROR_INVALID_ARGS;

 resource = vmci_resource_by_handle(handle,
        VMCI_RESOURCE_TYPE_DOORBELL);
 if (!resource) {
  pr_devel("Failed to destroy doorbell (handle=0x%x:0x%x)\n",
    handle.context, handle.resource);
  return VMCI_ERROR_NOT_FOUND;
 }

 entry = container_of(resource, struct dbell_entry, resource);

 if (!hlist_unhashed(&entry->node)) {
  int result;

  dbell_index_table_remove(entry);

  result = dbell_unlink(handle);
  if (VMCI_SUCCESS != result) {

   /*
 * The only reason this should fail would be
 * an inconsistency between guest and
 * hypervisor state, where the guest believes
 * it has an active registration whereas the
 * hypervisor doesn't. One case where this may
 * happen is if a doorbell is unregistered
 * following a hibernation at a time where the
 * doorbell state hasn't been restored on the
 * hypervisor side yet. Since the handle has
 * now been removed in the guest, we just
 * print a warning and return success.
 */
   pr_devel("Unlink of doorbell (handle=0x%x:0x%x) unknown by hypervisor (error=%d)\n",
     handle.context, handle.resource, result);
  }
 }

 /*
 * Now remove the resource from the table.  It might still be in use
 * after this, in a callback or still on the delayed work queue.
 */
 vmci_resource_put(&entry->resource);
 vmci_resource_remove(&entry->resource);

 kfree(entry);

 return VMCI_SUCCESS;
}
EXPORT_SYMBOL_GPL(vmci_doorbell_destroy);