subr_kobj.c

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

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_kobj.c
