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