Commit | Line | Data |
---|---|---|
bc63dedb GZ |
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; | |
bc63dedb GZ |
49 | unsigned int idx = vmci_resource_hash(handle); |
50 | ||
51 | rcu_read_lock(); | |
b67bfe0d | 52 | hlist_for_each_entry_rcu(r, |
bc63dedb GZ |
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; | |
bc63dedb GZ |
148 | |
149 | /* Remove resource from hash table. */ | |
150 | spin_lock(&vmci_resource_table.lock); | |
151 | ||
b67bfe0d | 152 | hlist_for_each_entry(r, &vmci_resource_table.entries[idx], node) { |
bc63dedb GZ |
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 | } |