1 /*- 2 * Copyright (c) 2000,2003 Doug Rabson 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/kernel.h> 32 #include <sys/kobj.h> 33 #include <sys/lock.h> 34 #include <sys/malloc.h> 35 #include <sys/mutex.h> 36 #include <sys/sysctl.h> 37 #ifndef TEST 38 #include <sys/systm.h> 39 #endif 40 41 #ifdef TEST 42 #include "usertest.h" 43 #endif 44 45 static MALLOC_DEFINE(M_KOBJ, "kobj", "Kernel object structures"); 46 47 #ifdef KOBJ_STATS 48 49 u_int kobj_lookup_hits; 50 u_int kobj_lookup_misses; 51 52 SYSCTL_UINT(_kern, OID_AUTO, kobj_hits, CTLFLAG_RD, 53 &kobj_lookup_hits, 0, ""); 54 SYSCTL_UINT(_kern, OID_AUTO, kobj_misses, CTLFLAG_RD, 55 &kobj_lookup_misses, 0, ""); 56 57 #endif 58 59 static struct mtx kobj_mtx; 60 static int kobj_next_id = 1; 61 62 SYSCTL_UINT(_kern, OID_AUTO, kobj_methodcount, CTLFLAG_RD, 63 &kobj_next_id, 0, ""); 64 65 static void 66 kobj_init_mutex(void *arg) 67 { 68 69 mtx_init(&kobj_mtx, "kobj", NULL, MTX_DEF); 70 } 71 72 SYSINIT(kobj, SI_SUB_LOCK, SI_ORDER_ANY, kobj_init_mutex, NULL); 73 74 /* 75 * This method structure is used to initialise new caches. Since the 76 * desc pointer is NULL, it is guaranteed never to match any read 77 * descriptors. 78 */ 79 static struct kobj_method null_method = { 80 0, 0, 81 }; 82 83 int 84 kobj_error_method(void) 85 { 86 87 return ENXIO; 88 } 89 90 static void 91 kobj_register_method(struct kobjop_desc *desc) 92 { 93 94 mtx_assert(&kobj_mtx, MA_OWNED); 95 if (desc->id == 0) { 96 desc->id = kobj_next_id++; 97 } 98 } 99 100 static void 101 kobj_unregister_method(struct kobjop_desc *desc) 102 { 103 } 104 105 static void 106 kobj_class_compile_common(kobj_class_t cls, kobj_ops_t ops) 107 { 108 kobj_method_t *m; 109 int i; 110 111 mtx_assert(&kobj_mtx, MA_OWNED); 112 113 /* 114 * Don't do anything if we are already compiled. 115 */ 116 if (cls->ops) 117 return; 118 119 /* 120 * First register any methods which need it. 121 */ 122 for (i = 0, m = cls->methods; m->desc; i++, m++) 123 kobj_register_method(m->desc); 124 125 /* 126 * Then initialise the ops table. 127 */ 128 for (i = 0; i < KOBJ_CACHE_SIZE; i++) 129 ops->cache[i] = &null_method; 130 ops->cls = cls; 131 cls->ops = ops; 132 } 133 134 void 135 kobj_class_compile(kobj_class_t cls) 136 { 137 kobj_ops_t ops; 138 139 mtx_assert(&kobj_mtx, MA_NOTOWNED); 140 141 /* 142 * Allocate space for the compiled ops table. 143 */ 144 ops = malloc(sizeof(struct kobj_ops), M_KOBJ, M_NOWAIT); 145 if (!ops) 146 panic("kobj_compile_methods: out of memory"); 147 148 mtx_lock(&kobj_mtx); 149 150 /* 151 * We may have lost a race for kobj_class_compile here - check 152 * to make sure someone else hasn't already compiled this 153 * class. 154 */ 155 if (cls->ops) { 156 mtx_unlock(&kobj_mtx); 157 free(ops, M_KOBJ); 158 return; 159 } 160 161 kobj_class_compile_common(cls, ops); 162 mtx_unlock(&kobj_mtx); 163 } 164 165 void 166 kobj_class_compile_static(kobj_class_t cls, kobj_ops_t ops) 167 { 168 169 mtx_assert(&kobj_mtx, MA_NOTOWNED); 170 171 /* 172 * Increment refs to make sure that the ops table is not freed. 173 */ 174 mtx_lock(&kobj_mtx); 175 cls->refs++; 176 kobj_class_compile_common(cls, ops); 177 mtx_unlock(&kobj_mtx); 178 } 179 180 static kobj_method_t* 181 kobj_lookup_method_class(kobj_class_t cls, kobjop_desc_t desc) 182 { 183 kobj_method_t *methods = cls->methods; 184 kobj_method_t *ce; 185 186 for (ce = methods; ce && ce->desc; ce++) { 187 if (ce->desc == desc) { 188 return ce; 189 } 190 } 191 192 return 0; 193 } 194 195 static kobj_method_t* 196 kobj_lookup_method_mi(kobj_class_t cls, 197 kobjop_desc_t desc) 198 { 199 kobj_method_t *ce; 200 kobj_class_t *basep; 201 202 ce = kobj_lookup_method_class(cls, desc); 203 if (ce) 204 return ce; 205 206 basep = cls->baseclasses; 207 if (basep) { 208 for (; *basep; basep++) { 209 ce = kobj_lookup_method_mi(*basep, desc); 210 if (ce) 211 return ce; 212 } 213 } 214 215 return 0; 216 } 217 218 kobj_method_t* 219 kobj_lookup_method(kobj_class_t cls, 220 kobj_method_t **cep, 221 kobjop_desc_t desc) 222 { 223 kobj_method_t *ce; 224 225 #ifdef KOBJ_STATS 226 /* 227 * Correct for the 'hit' assumption in KOBJOPLOOKUP and record 228 * a 'miss'. 229 */ 230 kobj_lookup_hits--; 231 kobj_lookup_misses--; 232 #endif 233 234 ce = kobj_lookup_method_mi(cls, desc); 235 if (!ce) 236 ce = desc->deflt; 237 *cep = ce; 238 return ce; 239 } 240 241 void 242 kobj_class_free(kobj_class_t cls) 243 { 244 int i; 245 kobj_method_t *m; 246 void* ops = 0; 247 248 mtx_assert(&kobj_mtx, MA_NOTOWNED); 249 mtx_lock(&kobj_mtx); 250 251 /* 252 * Protect against a race between kobj_create and 253 * kobj_delete. 254 */ 255 if (cls->refs == 0) { 256 /* 257 * Unregister any methods which are no longer used. 258 */ 259 for (i = 0, m = cls->methods; m->desc; i++, m++) 260 kobj_unregister_method(m->desc); 261 262 /* 263 * Free memory and clean up. 264 */ 265 ops = cls->ops; 266 cls->ops = 0; 267 } 268 269 mtx_unlock(&kobj_mtx); 270 271 if (ops) 272 free(ops, M_KOBJ); 273 } 274 275 kobj_t 276 kobj_create(kobj_class_t cls, 277 struct malloc_type *mtype, 278 int mflags) 279 { 280 kobj_t obj; 281 282 /* 283 * Allocate and initialise the new object. 284 */ 285 obj = malloc(cls->size, mtype, mflags | M_ZERO); 286 if (!obj) 287 return 0; 288 kobj_init(obj, cls); 289 290 return obj; 291 } 292 293 void 294 kobj_init(kobj_t obj, kobj_class_t cls) 295 { 296 mtx_assert(&kobj_mtx, MA_NOTOWNED); 297 retry: 298 mtx_lock(&kobj_mtx); 299 300 /* 301 * Consider compiling the class' method table. 302 */ 303 if (!cls->ops) { 304 /* 305 * kobj_class_compile doesn't want the lock held 306 * because of the call to malloc - we drop the lock 307 * and re-try. 308 */ 309 mtx_unlock(&kobj_mtx); 310 kobj_class_compile(cls); 311 goto retry; 312 } 313 314 obj->ops = cls->ops; 315 cls->refs++; 316 317 mtx_unlock(&kobj_mtx); 318 } 319 320 void 321 kobj_delete(kobj_t obj, struct malloc_type *mtype) 322 { 323 kobj_class_t cls = obj->ops->cls; 324 int refs; 325 326 /* 327 * Consider freeing the compiled method table for the class 328 * after its last instance is deleted. As an optimisation, we 329 * should defer this for a short while to avoid thrashing. 330 */ 331 mtx_assert(&kobj_mtx, MA_NOTOWNED); 332 mtx_lock(&kobj_mtx); 333 cls->refs--; 334 refs = cls->refs; 335 mtx_unlock(&kobj_mtx); 336 337 if (!refs) 338 kobj_class_free(cls); 339 340 obj->ops = 0; 341 if (mtype) 342 free(obj, mtype); 343 } 344