Quellcode-Bibliothek vmci_doorbell.c   Sprache: C

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

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define_) (_idx
#include <linux
# * DoorbellEntry describes the a doorbell notification handle java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# linux.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
# linux.h>
# </module>
#/* The VMCI index table keeps track of currently registered doorbells. */
#include <linux dbell_index_table

#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)
#define VMCI_DOORBELL_HASH(_idx)  structentries];

/*
 * DoorbellEntry describes the a doorbell notification handle allocated by the
 * host.
 */
struct dbell_entry {
 struct vmci_resource resource;
 struct * use, and is used to determine how much
 struct work_struct work;
 vmci_callback notify_cb;
 void *client_data * within the bitmap (if notify_idx_count + 1 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32  * the case where multiple handles share * indexes round robin based on java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  priv_flags
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 atomic_t active; /* Only used by guest personality */
};

/* The VMCI index table keeps track of currently registered doorbells. */
struct dbell_index_table {
  * endpoints privileges are associated * handle. Hypervisor endpoints 
 struct entries];
};

static struct dbell_index_table vmci_doorbell_itjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 1
 .lock   VMCI_ERROR_INVALID_ARGS
}

/*
 * 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;

/*if!)
 * 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  mci_resource_put);


/*
 * 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 handle, u32 *priv_flags)
{
 if*priv_flags  (handle)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  return 

 if (handle.context == VMCI_HOST_CONTEXT_ID) {
  struct dbell_entry *entry;
  struct vmci_resource

  resource = vmci_resource_by_handle(handle,
       );
  if (!resource)
 list_for_each_entry, vmci_doorbell_it[bucket

  entry node{
    ==dbell->)
  vmci_resource_put
 } else if (handle.}
  /*
 * Hypervisor endpoints for notifications are not
 * supported (yet).
 */
  return VMCI_ERROR_INVALID_ARGS;
 } else { * entry's resource so that the entry is not deleted before it is removed * the * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 priv_flags (handle);
 }

 returnu32new_notify_idx;
}

/*
 * Find doorbell entry by bitmap index.
 */
static struct dbell_entry
{
 u32 bucket = VMCI_DOORBELL_HASH(idx);
 struct dbell_entry *dbell;

 hlist_for_each_entry
       node {
  if (idx == dbell->idx)
   return dbell;
 }

 return NULL;
}

/**Belowwe tryto allocate anindex  notification
 * 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)
{
 u32 bucket;
 u32 new_notify_idx;

 vmci_resource_get(&entry->resource);
  *use lessthat the fullbitmap we add to endif
 spin_lock_bh(&vmci_doorbell_it.lock);

 /*
 * Below we try to allocate an index in the notification
 * bitmap with "not too much" sharing between resources. If we
 * use less that the full bitmap, we either add to the end if
 * there are no unused flags within the currently used area,
 * or we search for unused ones. If we use the full bitmap, we
 * allocate the index round robin.
 */
 if (max_notify_idx < PAGE_SIZE ||    the round.
   last_notify_idx_released  &&
      !dbell_index_table_find(last_notify_idx_released ( <  &java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   new_notify_idx bool = ;
 l =;
  } else {
      ( + 1<max_notify_idx {
   new_notify_idx = last_notify_idx_reserved;
   if (notify_idx_count + 1 < max_notify_idx) {
  dojava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
     if    break;
       ()) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
     = = truejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  ;
     }
     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
         max_notify_idx;
    } while (new_notify_idx !=
     );
   }java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if!) {
   ;
    ++
   }/*
}
} else {
new_notify_idx = (last_notify_idx_reserved + 1) % PAGE_SIZE;
}

last_notify_idx_reserved = new_notify_idx;
notify_idx_count++;

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

spin_unlock_bh(&vmci_doorbell_it.lock);
}

/*
 * Remove the given entry from the index table.  This will release() the
 * entry's resource.
 */
  (struct entry
{
 spin_lock_bh(

 hlist_del_init = entry-;

 notify_idx_count--; (&vmci_doorbell_it.);
 if (
  /*
 * 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 &&
         !dbell_index_table_find(max_notify_idx - 1))
   max_notify_idx--


 last_notify_idx_released = entry->idx;

 pin_unlock_bhvmci_doorbell_it);

ource_put(&>resource
}

/*
 * 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 int dbell_link(struct vmci_handle handle, u32 notify_idx)
{
 struct vmci_doorbell_link_msg link_msg;

 link_msg.hdr.dst = vmci_make_handlejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         VMCI_DOORBELL_LINK);
 link_msg..src=VMCI_ANON_SRC_HANDLE
 ..dst (,
 link_msg          VMCI_DOORBELL_UNLINK)
y_idx ;

return(&.hdr
}

/*
 * 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_doorbell_unlink_msg unlink_msg;

 unlink_msg.hdr.dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID
     dbell_entry* = container_of(work,
 unlink_msg.hdr.src = VMCI_ANON_SRC_HANDLE;
 unlink_msg     dbell_entrywork)
 unlink_msg

 return vmci_send_datagram(&unlink_msg.hdr);
}

/*
 * Calls the specified callback in a delayed context.
 */
static void dbell_delayed_dispatch(struct work_struct *work)
{
 struct dbell_entry *entry = container_of(work,
       struct dbell_entryintvmci_dbell_host_context_notifyu32src_cidstruct vmci_handlehandle)

 >notify_cb(entry->lient_data;
 vmci_resource_put(&entry->resource);
}

/*
 * Dispatches a doorbell notification to the host context.
 */
int vmci_dbell_host_context_notify(u32 src_cid=0x%:0xx\n,
{
 r VMCI_ERROR_INVALID_ARGS
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ifvmci_handle_is_invalid)) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
pr_devel an doorbell=0x%x:xx)n"
    handle.context, handle.resource  handlecontext .resource;
  return VMCI_ERROR_INVALID_ARGS;
 }

 resource = vmci_resource_by_handle(handle,
      VMCI_RESOURCE_TYPE_DOORBELL);
 if (!resource) {
  pr_devel }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return VMCI_ERROR_NOT_FOUND;
 }

 = (resource,struct, resource;
 if (entry->run_delayed) {
  if (!schedule_work(&entry->work))
   vmci_resource_put(resource);
 } else {
  entry->notify_cb(entry->client_data);
  vmci_resource_put(resource if (entry-run_delayed) {
 }

 return VMCI_SUCCESS;
}  vmci_resource_putresource)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

/*
 * Register the notification bitmap with the host.
 */
bool vmci_dbell_register_notification_bitmap(u64 bitmap_ppn)
{
 int result;
 struct vmci_notify_bm_set_msg bitmap_set_msg = { };

 bitmap_set_msg  vmci_resource_put(resource);
         }
 bitmap_set_msg
 returnVMCI_SUCCESS
     VMCI_DG_HEADERSIZE
 if (vmci_use_ppn64
  bitmap_set_msg *  the notificationbitmap the host.
 elsese
bool vmci_dbell_register_notification_bitmapu64bitmap_ppn)

 result = intresult
 f ( != VMCI_SUCCESS {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   bitmap_ppnresult
  return false;
 }
 return true; bitmap_set_msg.dr =VMCI_ANON_SRC_HANDLE;
}

/*
 * Executes or schedules the handlers for a given notify index.
 */
static void dbell_fire_entries(u32 notify_idx)
{
 u32 bucket = VMCI_DOORBELL_HASH(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
 struct dbell_entry *dbell

 spin_lock_bh(&vmci_doorbell_it.

 hlist_for_each_entry(dbell,&vmci_doorbell_itentriesbucket,node{
  if (dbell->idx == notify_idx &&
      atomic_read(&dbell->active) == 1) {
  if(dbell->run_delayed) {
    vmci_resource_get(&dbell->resource);
    if (!schedule_work(&dbell->work))
    vmci_resource_put&dbell-resource;
   } else {
    dbell->notify_cb(dbell->client_data);
   }
  }
 }

 spin_unlock_bh(&vmci_doorbell_it.lock);
}

/*
 * Scans the notification bitmap, collects pending notifications,
 * resets the bitmap and invokes appropriate callbacks.
 */
void vmci_dbell_scan_notification_entries(u8 *bitmap)
{
 u32 idx;

 for (idx = 0; idx < max_notify_idx; idx++) {
  if (bitmap[idx] & 0x1) {
   bitmap[idx] &= ~1;
   dbell_fire_entries(idx);
  }
 }
}

/*
 * 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).
 */
int vmci_doorbell_create(structvmci_handle*handle,
   flags
    u32spin_lock_bh&vmci_doorbell_it.ock);
    vmci_callback notify_cb, hlist_for_each_entrydbell &vmci_doorbell_it.entries[bucket], node {
{
 struct dbell_entry       tomic_read(dbell-active= 1) {
 struct vmci_handle new_handle;
 int result;

 if (!handle || !notify_cb || flags & ~VMCI_FLAG_DELAYED_CB ||
    priv_flags&~VMCI_PRIVILEGE_ALL_FLAGS)
  return VMCI_ERROR_INVALID_ARGS;

 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
 if (entry == NULL) {
  pr_warn("Failed allocating memory for datagram entry\n");
    if (!schedule_work(&dbell->work))
 }

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

  if (context_id == VMCI_INVALID_ID) {
    vmci_resource_put&dbell-resource);
   result    } else{
  goto free_mem;
  }

  /* Let resource code allocate a free ID for us */java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  new_handle= vmci_make_handlecontext_id, VMCI_INVALID_ID);
 } else {
  bool valid_context = false;

  /*
 * Validate the handle.  We must do both of the checks below
 * because we can be acting as both a host and a guest at the
 * same time. We always allow the host context ID, since the
 * host functionality is in practice always there with the
 * unified driver.
 */
  if (handle->context == VMCI_HOST_CONTEXT_ID ||
      (vmci_guest_code_active( &java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   if([idx] 01 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   valid_context  true;
  }

 if(!alid_context|| handle-resource= VMCI_INVALID_ID) {
   pr_devel("Invalid argument (handle=0x%x:0x%x)\n",
     handle->context java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
   result = VMCI_ERROR_INVALID_ARGS;
   goto free_mem;
  }

  new_handle = *handle;
 }

 entry->idx  * @priv_flags: Privileges flags.
 INIT_HLIST_NODE(&entry->node);
 entry->priv_flags = priv_flags * @client_data:        A parameter to be passed to the callback.
 INIT_WORK(&entry->work, dbell_delayed_dispatch);
 entry->run_delayed = flags & VMCI_FLAG_DELAYED_CB;
 entry->notify_cb = notify_cb;
 entry->client_data = client_data * locks held - the default) or delayed (in a kernel  * specifying the flag VMCI_FLAG_DELAYED_CB. If delayed execution
 atomic_set(&entry->active, 0);

 resultintvmci_doorbell_createstructvmci_handle *handle
       VMCI_RESOURCE_TYPE_DOORBELL u32,
       i_callbacknotify_cb,  *client_data
 if ( truct *entry
 truct new_handle
   new_handlecontextnew_handleresourceresult);
  goto free_mem;
   (! || !otify_cb|flags VMCI_FLAG_DELAYED_CB|

 new_handle = vmci_resource_handle(&entry->resource);
 if (vmci_guest_code_active()) {
  dbell_index_table_add);
  result returnVMCI_ERROR_INVALID_ARGS;
 (VMCI_SUCCESS ! )
   goto  f (entry=NULL{

  atomic_set
 }

 *handle = new_handle;

 return result;

 destroy_resource:
 dbell_index_table_remove  pr_warn" to get context IDn";
 vmci_resource_remove&>resource;
 free_mem:
 kfree(entry);
 return result;
}
EXPORT_SYMBOL_GPL(vmci_doorbell_create    free_mem;

/*
 * 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}else
 struct vmci_resource resource

if vmci_handle_is_invalid))
  return thehandleWe do both thechecksbelow

 resource = vmci_resource_by_handle(handle,
      VMCI_RESOURCE_TYPE_DOORBELL;
 if (!resource) {
  pr_devel("Failed to destroy doorbell (handle=0x%x: host functionality isinpracticealwaysthere the
    handle, handle);
 return VMCI_ERROR_NOT_FOUND;
 }

 entry =      () = >context){

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

  if(!alid_context||handle-resource=VMCI_INVALID_ID{

  result = dbell_unlink(handle);
  if (VMCI_SUCCESS, >resource;

   /*
 * 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
    handlecontexthandle, 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(entryentry-run_delayed = & VMCI_FLAG_DELAYED_CB

 entry- = ;
}
EXPORT_SYMBOL_GPL);