drivers/misc/vmw_vmci/vmci_resource.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * VMware VMCI Driver
   4  *
   5  * Copyright (C) 2012 VMware, Inc. All rights reserved.
   6  */
   7
   8 #include <linux/vmw_vmci_defs.h>
   9 #include <linux/hash.h>
  10 #include <linux/types.h>
  11 #include <linux/rculist.h>
  12 #include <linux/completion.h>
  13
  14 #include "vmci_resource.h"
  15 #include "vmci_driver.h"
  16
  17
  18 #define VMCI_RESOURCE_HASH_BITS         7
  19 #define VMCI_RESOURCE_HASH_BUCKETS      (1 << VMCI_RESOURCE_HASH_BITS)
  20
  21 struct vmci_hash_table {
  22         spinlock_t lock;
  23         struct hlist_head entries[VMCI_RESOURCE_HASH_BUCKETS];
  24 };
  25
  26 static struct vmci_hash_table vmci_resource_table = {
  27         .lock = __SPIN_LOCK_UNLOCKED(vmci_resource_table.lock),
  28 };
  29
  30 static unsigned int vmci_resource_hash(struct vmci_handle handle)
  31 {
  32         return hash_32(handle.resource, VMCI_RESOURCE_HASH_BITS);
  33 }
  34
  35 /*
  36  * Gets a resource (if one exists) matching given handle from the hash table.
  37  */
  38 static struct vmci_resource *vmci_resource_lookup(struct vmci_handle handle,
  39                                                   enum vmci_resource_type type)
  40 {
  41         struct vmci_resource *r, *resource = NULL;
  42         unsigned int idx = vmci_resource_hash(handle);
  43
  44         rcu_read_lock();
  45         hlist_for_each_entry_rcu(r,
  46                                  &vmci_resource_table.entries[idx], node) {
  47                 u32 cid = r->handle.context;
  48                 u32 rid = r->handle.resource;
  49
  50                 if (r->type == type &&
  51                     rid == handle.resource &&
  52                     (cid == handle.context || cid == VMCI_INVALID_ID ||
  53                      handle.context == VMCI_INVALID_ID)) {
  54                         resource = r;
  55                         break;
  56                 }
  57         }
  58         rcu_read_unlock();
  59
  60         return resource;
  61 }
  62
  63 /*
  64  * Find an unused resource ID and return it. The first
  65  * VMCI_RESERVED_RESOURCE_ID_MAX are reserved so we start from
  66  * its value + 1.
  67  * Returns VMCI resource id on success, VMCI_INVALID_ID on failure.
  68  */
  69 static u32 vmci_resource_find_id(u32 context_id,
  70                                  enum vmci_resource_type resource_type)
  71 {
  72         static u32 resource_id = VMCI_RESERVED_RESOURCE_ID_MAX + 1;
  73         u32 old_rid = resource_id;
  74         u32 current_rid;
  75
  76         /*
  77          * Generate a unique resource ID.  Keep on trying until we wrap around
  78          * in the RID space.
  79          */
  80         do {
  81                 struct vmci_handle handle;
  82
  83                 current_rid = resource_id;
  84                 resource_id++;
  85                 if (unlikely(resource_id == VMCI_INVALID_ID)) {
  86                         /* Skip the reserved rids. */
  87                         resource_id = VMCI_RESERVED_RESOURCE_ID_MAX + 1;
  88                 }
  89
  90                 handle = vmci_make_handle(context_id, current_rid);
  91                 if (!vmci_resource_lookup(handle, resource_type))
  92                         return current_rid;
  93         } while (resource_id != old_rid);
  94
  95         return VMCI_INVALID_ID;
  96 }
  97
  98
  99 int vmci_resource_add(struct vmci_resource *resource,
 100                       enum vmci_resource_type resource_type,
 101                       struct vmci_handle handle)
 102
 103 {
 104         unsigned int idx;
 105         int result;
 106
 107         spin_lock(&vmci_resource_table.lock);
 108
 109         if (handle.resource == VMCI_INVALID_ID) {
 110                 handle.resource = vmci_resource_find_id(handle.context,
 111                         resource_type);
 112                 if (handle.resource == VMCI_INVALID_ID) {
 113                         result = VMCI_ERROR_NO_HANDLE;
 114                         goto out;
 115                 }
 116         } else if (vmci_resource_lookup(handle, resource_type)) {
 117                 result = VMCI_ERROR_ALREADY_EXISTS;
 118                 goto out;
 119         }
 120
 121         resource->handle = handle;
 122         resource->type = resource_type;
 123         INIT_HLIST_NODE(&resource->node);
 124         kref_init(&resource->kref);
 125         init_completion(&resource->done);
 126
 127         idx = vmci_resource_hash(resource->handle);
 128         hlist_add_head_rcu(&resource->node, &vmci_resource_table.entries[idx]);
 129
 130         result = VMCI_SUCCESS;
 131
 132 out:
 133         spin_unlock(&vmci_resource_table.lock);
 134         return result;
 135 }
 136
 137 void vmci_resource_remove(struct vmci_resource *resource)
 138 {
 139         struct vmci_handle handle = resource->handle;
 140         unsigned int idx = vmci_resource_hash(handle);
 141         struct vmci_resource *r;
 142
 143         /* Remove resource from hash table. */
 144         spin_lock(&vmci_resource_table.lock);
 145
 146         hlist_for_each_entry(r, &vmci_resource_table.entries[idx], node) {
 147                 if (vmci_handle_is_equal(r->handle, resource->handle)) {
 148                         hlist_del_init_rcu(&r->node);
 149                         break;
 150                 }
 151         }
 152
 153         spin_unlock(&vmci_resource_table.lock);
 154         synchronize_rcu();
 155
 156         vmci_resource_put(resource);
 157         wait_for_completion(&resource->done);
 158 }
 159
 160 struct vmci_resource *
 161 vmci_resource_by_handle(struct vmci_handle resource_handle,
 162                         enum vmci_resource_type resource_type)
 163 {
 164         struct vmci_resource *r, *resource = NULL;
 165
 166         rcu_read_lock();
 167
 168         r = vmci_resource_lookup(resource_handle, resource_type);
 169         if (r &&
 170             (resource_type == r->type ||
 171              resource_type == VMCI_RESOURCE_TYPE_ANY)) {
 172                 resource = vmci_resource_get(r);
 173         }
 174
 175         rcu_read_unlock();
 176
 177         return resource;
 178 }
 179
 180 /*
 181  * Get a reference to given resource.
 182  */
 183 struct vmci_resource *vmci_resource_get(struct vmci_resource *resource)
 184 {
 185         kref_get(&resource->kref);
 186
 187         return resource;
 188 }
 189
 190 static void vmci_release_resource(struct kref *kref)
 191 {
 192         struct vmci_resource *resource =
 193                 container_of(kref, struct vmci_resource, kref);
 194
 195         /* Verify the resource has been unlinked from hash table */
 196         WARN_ON(!hlist_unhashed(&resource->node));
 197
 198         /* Signal that container of this resource can now be destroyed */
 199         complete(&resource->done);
 200 }
 201
 202 /*
 203  * Resource's release function will get called if last reference.
 204  * If it is the last reference, then we are sure that nobody else
 205  * can increment the count again (it's gone from the resource hash
 206  * table), so there's no need for locking here.
 207  */
 208 int vmci_resource_put(struct vmci_resource *resource)
 209 {
 210         /*
 211          * We propagate the information back to caller in case it wants to know
 212          * whether entry was freed.
 213          */
 214         return kref_put(&resource->kref, vmci_release_resource) ?
 215                 VMCI_SUCCESS_ENTRY_DEAD : VMCI_SUCCESS;
 216 }
 217
 218 struct vmci_handle vmci_resource_handle(struct vmci_resource *resource)
 219 {
 220         return resource->handle;
 221 }