drivers/misc/vmw_vmci/vmci_resource.c

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