diff --git a/share/man/man9/osd.9 b/share/man/man9/osd.9 index 95547f5211c2..5e0e482914c3 100644 --- a/share/man/man9/osd.9 +++ b/share/man/man9/osd.9 @@ -1,448 +1,448 @@ .\" .\" Copyright (c) 2010 Lawrence Stewart .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions, and the following disclaimer, .\" without modification, immediately at the beginning of the file. .\" 2. The name of the author may not be used to endorse or promote products .\" derived from this software without specific prior written permission. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR .\" ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" -.Dd April 26, 2016 +.Dd October 07, 2024 .Dt OSD 9 .Os .Sh NAME .Nm osd , .Nm osd_register , .Nm osd_deregister , .Nm osd_set , .Nm osd_reserve , .Nm osd_set_reserved , .Nm osd_free_reserved , .Nm osd_get , .Nm osd_del , .Nm osd_call , .Nm osd_exit .Nd Object Specific Data .Sh SYNOPSIS .In sys/osd.h .Ft typedef void .Fn "\*(lp*osd_destructor_t\*(rp" "void *value" .Ft typedef int .Fn "\*(lp*osd_method_t\*(rp" "void *obj" "void *data" .Ft int .Fo osd_register .Fa "u_int type" .Fa "osd_destructor_t destructor" -.Fa "osd_method_t *methods" +.Fa "const osd_method_t *methods" .Fc .Ft void .Fo osd_deregister .Fa "u_int type" .Fa "u_int slot" .Fc .Ft int .Fo osd_set .Fa "u_int type" .Fa "struct osd *osd" .Fa "u_int slot" .Fa "void *value" .Fc .Ft void ** .Fo osd_reserve .Fa "u_int slot" .Fc .Ft int .Fo osd_set_reserved .Fa "u_int type" .Fa "struct osd *osd" .Fa "u_int slot" .Fa "void **rsv" .Fa "void *value" .Fc .Ft void .Fo osd_free_reserved .Fa "void **rsv" .Fc .Ft void * .Fo osd_get .Fa "u_int type" .Fa "struct osd *osd" .Fa "u_int slot" .Fc .Ft void .Fo osd_del .Fa "u_int type" .Fa "struct osd *osd" .Fa "u_int slot" .Fc .Ft int .Fo osd_call .Fa "u_int type" .Fa "u_int method" .Fa "void *obj" .Fa "void *data" .Fc .Ft void .Fo osd_exit .Fa "u_int type" .Fa "struct osd *osd" .Fc .Sh DESCRIPTION The .Nm framework provides a mechanism to dynamically associate arbitrary data at run-time with any kernel data structure which has been suitably modified for use with .Nm . The one-off modification required involves embedding a .Vt "struct osd" inside the kernel data structure. .Pp An additional benefit is that after the initial change to a structure is made, all subsequent use of .Nm with the structure involves no changes to the structure's layout. By extension, if the data structure is part of the ABI, .Nm provides a way of extending the structure in an ABI preserving manner. .Pp The details of the embedded .Vt "struct osd" are not relevant to consumers of the .Nm framework and should not be manipulated directly. .Pp Data associated with a structure is referenced by the .Nm framework using a type/slot identifier pair. Types are statically defined in .In sys/osd.h and provide a high-level grouping for slots to be registered under. Slot identifiers are dynamically assigned by the framework when a data type is registered using .Fn osd_register and remains valid until a corresponding call to .Fn osd_deregister . .Ss Functions The .Fn osd_register function registers a type/slot identifier pair with the .Nm framework for use with a new data type. The function may sleep and therefore cannot be called from a non-sleepable context. The .Fa type argument specifies which high-level type grouping from .In sys/osd.h the slot identifier should be allocated under. The .Fa destructor argument specifies an optional osd_destructor_t function pointer that will be called for objects of the type being registered which are later destroyed by the .Fn osd_del function. NULL may be passed if no destructor is required. The .Fa methods argument specifies an optional array of osd_method_t function pointers which can be later invoked by the .Fn osd_call function. NULL may be passed if no methods are required. The .Fa methods argument is currently only useful with the OSD_JAIL type identifier. .Pp The .Fn osd_deregister function deregisters a previously registered type/slot identifier pair. The function may sleep and therefore cannot be called from a non-sleepable context. The .Fa type argument specifies which high-level type grouping from .In sys/osd.h the slot identifier is allocated under. The .Fa slot argument specifies the slot identifier which is being deregistered and should be the value that was returned by .Fn osd_register when the data type was registered. .Pp The .Fn osd_set function associates a data object pointer with a kernel data structure's .Vt struct osd member. The .Fa type argument specifies which high-level type grouping from .In sys/osd.h the slot identifier is allocated under. The .Fa osd argument is a pointer to the kernel data structure's .Vt struct osd which will have the .Fa value pointer associated with it. The .Fa slot argument specifies the slot identifier to assign the .Fa value pointer to. The .Fa value argument points to a data object to associate with .Fa osd . .Pp The .Fn osd_set_reserved function does the same as .Fn osd_set , but with an extra argument .Fa rsv that is internal-use memory previously allocated via .Fn osd_reserve . .Pp The .Fn osd_get function returns the data pointer associated with a kernel data structure's .Vt struct osd member from the specified type/slot identifier pair. The .Fa type argument specifies which high-level type grouping from .In sys/osd.h the slot identifier is allocated under. The .Fa osd argument is a pointer to the kernel data structure's .Vt struct osd to retrieve the data pointer from. The .Fa slot argument specifies the slot identifier to retrieve the data pointer from. .Pp The .Fn osd_del function removes the data pointer associated with a kernel data structure's .Vt struct osd member from the specified type/slot identifier pair. The .Fa type argument specifies which high-level type grouping from .In sys/osd.h the slot identifier is allocated under. The .Fa osd argument is a pointer to the kernel data structure's .Vt struct osd to remove the data pointer from. The .Fa slot argument specifies the slot identifier to remove the data pointer from. If an osd_destructor_t function pointer was specified at registration time, the destructor function will be called and passed the data pointer for the type/slot identifier pair which is being deleted. .Pp The .Fn osd_call function calls the specified osd_method_t function pointer for all currently registered slots of a given type on the specified .Fa obj and .Fa data pointers. The function may sleep and therefore cannot be called from a non-sleepable context. The .Fa type argument specifies which high-level type grouping from .In sys/osd.h to call the method for. The .Fa method argument specifies the index into the osd_method_t array that was passed to .Fn osd_register . The .Fa obj and .Fa data arguments are passed to the method function pointer of each slot. .Pp The .Fn osd_exit function removes all data object pointers from all currently registered slots for a given type for the specified kernel data structure's .Vt struct osd member. The .Fa type argument specifies which high-level type grouping from .In sys/osd.h to remove data pointers from. The .Fa osd argument is a pointer to the kernel data structure's .Vt struct osd to remove all data object pointers for all currently registered slots from. .Sh IMPLEMENTATION NOTES .Nm uses a two dimensional matrix (array of arrays) as the data structure to manage the external data associated with a kernel data structure's .Vt struct osd member. The type identifier is used as the index into the outer array, and the slot identifier is used as the index into the inner array. To set or retrieve a data pointer for a given type/slot identifier pair, .Fn osd_set and .Fn osd_get perform the equivalent of array[type][slot], which is both constant time and fast. .Pp If .Fn osd_set is called on a .Vt struct osd for the first time, the array for storing data pointers is dynamically allocated using .Xr malloc 9 with M_NOWAIT to a size appropriate for the slot identifier being set. If a subsequent call to .Fn osd_set attempts to set a slot identifier which is numerically larger than the slot used in the previous .Fn osd_set call, .Xr realloc 9 is used to grow the array to the appropriate size such that the slot identifier can be used. To maximise the efficiency of any code which calls .Fn osd_set sequentially on a number of different slot identifiers (e.g., during an initialisation phase) one should loop through the slot identifiers in descending order from highest to lowest. This will result in only a single .Xr malloc 9 call to create an array of the largest slot size and all subsequent calls to .Fn osd_set will proceed without any .Xr realloc 9 calls. .Pp It is possible for .Fn osd_set to fail to allocate this array. To ensure that such allocation succeeds, .Fn osd_reserve may be called (in a non-blocking context), and it will pre-allocate the memory via .Xr malloc 9 with M_WAITOK. Then this pre-allocated memory is passed to .Fn osd_set_reserved , which will use it if necessary or otherwise discard it. The memory may also be explicitly discarded by calling .Fn osd_free_reserved . As this method always allocates memory whether or not it is ultimately needed, it should be used only rarely, such as in the unlikely event that .Fn osd_set fails. .Pp The .Nm API is geared towards slot identifiers storing pointers to the same underlying data structure type for a given .Nm type identifier. This is not a requirement, and .Xr khelp 9 for example stores completely different data types in slots under the OSD_KHELP type identifier. .Ss Locking .Nm internally uses a mix of .Xr mutex 9 , .Xr rmlock 9 and .Xr sx 9 locks to protect its internal data structures and state. .Pp Responsibility for synchronising access to a kernel data structure's .Vt struct osd member is left to the subsystem that uses the data structure and calls the .Nm API. .Pp .Fn osd_get only acquires an .Xr rmlock 9 in read mode, therefore making it safe to use in the majority of contexts within the kernel including most fast paths. .Sh RETURN VALUES .Fn osd_register returns the slot identifier for the newly registered data type. .Pp .Fn osd_set and .Fn osd_set_reserved return zero on success or ENOMEM if the specified type/slot identifier pair triggered an internal .Xr realloc 9 which failed .Ns ( .Fn osd_set_reserved will always succeed when .Fa rsv is non-NULL). .Pp .Fn osd_get returns the data pointer for the specified type/slot identifier pair, or NULL if the slot has not been initialised yet. .Pp .Fn osd_reserve returns a pointer suitable for passing to .Fn osd_set_reserved or .Fn osd_free_reserved . .Pp .Fn osd_call returns zero if no method is run or the method for each slot runs successfully. If a method for a slot returns non-zero, .Fn osd_call terminates prematurely and returns the method's error to the caller. .Sh SEE ALSO .Xr khelp 9 .Sh HISTORY The Object Specific Data (OSD) facility first appeared in .Fx 8.0 . .Sh AUTHORS .An -nosplit The .Nm facility was written by .An Pawel Jakub Dawidek Aq Mt pjd@FreeBSD.org . .Pp This manual page was written by .An Lawrence Stewart Aq Mt lstewart@FreeBSD.org . diff --git a/sys/kern/kern_osd.c b/sys/kern/kern_osd.c index dcd80a948ea7..93809ccab8e5 100644 --- a/sys/kern/kern_osd.c +++ b/sys/kern/kern_osd.c @@ -1,443 +1,443 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2007 Pawel Jakub Dawidek * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* OSD (Object Specific Data) */ /* * Lock key: * (m) osd_module_lock * (o) osd_object_lock * (l) osd_list_lock */ struct osd_master { struct sx osd_module_lock; struct rmlock osd_object_lock; struct mtx osd_list_lock; LIST_HEAD(, osd) osd_list; /* (l) */ osd_destructor_t *osd_destructors; /* (o) */ osd_method_t *osd_methods; /* (m) */ u_int osd_ntslots; /* (m) */ const u_int osd_nmethods; }; static MALLOC_DEFINE(M_OSD, "osd", "Object Specific Data"); static int osd_debug = 0; SYSCTL_INT(_debug, OID_AUTO, osd, CTLFLAG_RWTUN, &osd_debug, 0, "OSD debug level"); #define OSD_DEBUG(...) do { \ if (osd_debug) { \ printf("OSD (%s:%u): ", __func__, __LINE__); \ printf(__VA_ARGS__); \ printf("\n"); \ } \ } while (0) static void do_osd_del(u_int type, struct osd *osd, u_int slot, int list_locked); /* * List of objects with OSD. */ struct osd_master osdm[OSD_LAST + 1] = { [OSD_JAIL] = { .osd_nmethods = PR_MAXMETHOD }, }; static void osd_default_destructor(void *value __unused) { /* Do nothing. */ } int -osd_register(u_int type, osd_destructor_t destructor, osd_method_t *methods) +osd_register(u_int type, osd_destructor_t destructor, const osd_method_t *methods) { void *newptr; u_int i, m; KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type.")); /* * If no destructor is given, use default one. We need to use some * destructor, because NULL destructor means unused slot. */ if (destructor == NULL) destructor = osd_default_destructor; sx_xlock(&osdm[type].osd_module_lock); /* * First, we try to find unused slot. */ for (i = 0; i < osdm[type].osd_ntslots; i++) { if (osdm[type].osd_destructors[i] == NULL) { OSD_DEBUG("Unused slot found (type=%u, slot=%u).", type, i + 1); break; } } /* * If no unused slot was found, allocate one. */ if (i == osdm[type].osd_ntslots) { osdm[type].osd_ntslots++; if (osdm[type].osd_nmethods != 0) osdm[type].osd_methods = realloc(osdm[type].osd_methods, sizeof(osd_method_t) * osdm[type].osd_ntslots * osdm[type].osd_nmethods, M_OSD, M_WAITOK); newptr = malloc(sizeof(osd_destructor_t) * osdm[type].osd_ntslots, M_OSD, M_WAITOK); rm_wlock(&osdm[type].osd_object_lock); bcopy(osdm[type].osd_destructors, newptr, sizeof(osd_destructor_t) * i); free(osdm[type].osd_destructors, M_OSD); osdm[type].osd_destructors = newptr; rm_wunlock(&osdm[type].osd_object_lock); OSD_DEBUG("New slot allocated (type=%u, slot=%u).", type, i + 1); } osdm[type].osd_destructors[i] = destructor; if (osdm[type].osd_nmethods != 0) { for (m = 0; m < osdm[type].osd_nmethods; m++) osdm[type].osd_methods[i * osdm[type].osd_nmethods + m] = methods != NULL ? methods[m] : NULL; } sx_xunlock(&osdm[type].osd_module_lock); return (i + 1); } void osd_deregister(u_int type, u_int slot) { struct osd *osd, *tosd; KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type.")); KASSERT(slot > 0, ("Invalid slot.")); sx_xlock(&osdm[type].osd_module_lock); rm_wlock(&osdm[type].osd_object_lock); KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot.")); /* * Free all OSD for the given slot. */ mtx_lock(&osdm[type].osd_list_lock); LIST_FOREACH_SAFE(osd, &osdm[type].osd_list, osd_next, tosd) do_osd_del(type, osd, slot, 1); mtx_unlock(&osdm[type].osd_list_lock); /* * Set destructor to NULL to free the slot. We don't bother actually * freeing any memory here because we'll gracefully reuse any freed * slots, and reallocating the arrays as a smaller chunk of memory isn't * actually guaranteed to succeed. As such, we'll err on the side of * caution and just leave it be since these are generally modestly sized * allocations. */ osdm[type].osd_destructors[slot - 1] = NULL; OSD_DEBUG("Slot deregistration (type=%u, slot=%u).", type, slot); rm_wunlock(&osdm[type].osd_object_lock); sx_xunlock(&osdm[type].osd_module_lock); } int osd_set(u_int type, struct osd *osd, u_int slot, void *value) { return (osd_set_reserved(type, osd, slot, NULL, value)); } void ** osd_reserve(u_int slot) { KASSERT(slot > 0, ("Invalid slot.")); OSD_DEBUG("Reserving slot array (slot=%u).", slot); return (malloc(sizeof(void *) * slot, M_OSD, M_WAITOK | M_ZERO)); } int osd_set_reserved(u_int type, struct osd *osd, u_int slot, void **rsv, void *value) { struct rm_priotracker tracker; KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type.")); KASSERT(slot > 0, ("Invalid slot.")); rm_rlock(&osdm[type].osd_object_lock, &tracker); KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot.")); if (slot > osd->osd_nslots) { void **newptr; if (value == NULL) { OSD_DEBUG( "Not allocating null slot (type=%u, slot=%u).", type, slot); rm_runlock(&osdm[type].osd_object_lock, &tracker); if (rsv) osd_free_reserved(rsv); return (0); } /* * Too few slots allocated here, so we need to extend or create * the array. */ if (rsv) { /* * Use the reserve passed in (assumed to be * the right size). */ newptr = rsv; if (osd->osd_nslots != 0) { memcpy(newptr, osd->osd_slots, sizeof(void *) * osd->osd_nslots); free(osd->osd_slots, M_OSD); } } else { newptr = realloc(osd->osd_slots, sizeof(void *) * slot, M_OSD, M_NOWAIT | M_ZERO); if (newptr == NULL) { rm_runlock(&osdm[type].osd_object_lock, &tracker); return (ENOMEM); } } if (osd->osd_nslots == 0) { /* * First OSD for this object, so we need to put it * onto the list. */ mtx_lock(&osdm[type].osd_list_lock); LIST_INSERT_HEAD(&osdm[type].osd_list, osd, osd_next); mtx_unlock(&osdm[type].osd_list_lock); OSD_DEBUG("Setting first slot (type=%u).", type); } else OSD_DEBUG("Growing slots array (type=%u).", type); osd->osd_slots = newptr; osd->osd_nslots = slot; } else if (rsv) osd_free_reserved(rsv); OSD_DEBUG("Setting slot value (type=%u, slot=%u, value=%p).", type, slot, value); osd->osd_slots[slot - 1] = value; rm_runlock(&osdm[type].osd_object_lock, &tracker); return (0); } void osd_free_reserved(void **rsv) { OSD_DEBUG("Discarding reserved slot array."); free(rsv, M_OSD); } void * osd_get_unlocked(u_int type, struct osd *osd, u_int slot) { void *value; KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot.")); if (slot > osd->osd_nslots) { value = NULL; OSD_DEBUG("Slot doesn't exist (type=%u, slot=%u).", type, slot); } else { value = atomic_load_ptr(&osd->osd_slots[slot - 1]); OSD_DEBUG("Returning slot value (type=%u, slot=%u, value=%p).", type, slot, value); } return (value); } void * osd_get(u_int type, struct osd *osd, u_int slot) { struct rm_priotracker tracker; void *value; KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type.")); KASSERT(slot > 0, ("Invalid slot.")); rm_rlock(&osdm[type].osd_object_lock, &tracker); value = osd_get_unlocked(type, osd, slot); rm_runlock(&osdm[type].osd_object_lock, &tracker); return (value); } void osd_del(u_int type, struct osd *osd, u_int slot) { struct rm_priotracker tracker; rm_rlock(&osdm[type].osd_object_lock, &tracker); do_osd_del(type, osd, slot, 0); rm_runlock(&osdm[type].osd_object_lock, &tracker); } static void do_osd_del(u_int type, struct osd *osd, u_int slot, int list_locked) { int i; KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type.")); KASSERT(slot > 0, ("Invalid slot.")); KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot.")); OSD_DEBUG("Deleting slot (type=%u, slot=%u).", type, slot); if (slot > osd->osd_nslots) { OSD_DEBUG("Slot doesn't exist (type=%u, slot=%u).", type, slot); return; } if (osd->osd_slots[slot - 1] != NULL) { osdm[type].osd_destructors[slot - 1](osd->osd_slots[slot - 1]); osd->osd_slots[slot - 1] = NULL; } for (i = osd->osd_nslots - 1; i >= 0; i--) { if (osd->osd_slots[i] != NULL) { OSD_DEBUG("Slot still has a value (type=%u, slot=%u).", type, i + 1); break; } } if (i == -1) { /* No values left for this object. */ OSD_DEBUG("No more slots left (type=%u).", type); if (!list_locked) mtx_lock(&osdm[type].osd_list_lock); LIST_REMOVE(osd, osd_next); if (!list_locked) mtx_unlock(&osdm[type].osd_list_lock); free(osd->osd_slots, M_OSD); osd->osd_slots = NULL; osd->osd_nslots = 0; } else if (slot == osd->osd_nslots) { /* This was the last slot. */ osd->osd_slots = realloc(osd->osd_slots, sizeof(void *) * (i + 1), M_OSD, M_NOWAIT | M_ZERO); /* * We always reallocate to smaller size, so we assume it will * always succeed. */ KASSERT(osd->osd_slots != NULL, ("realloc() failed")); osd->osd_nslots = i + 1; OSD_DEBUG("Reducing slots array to %u (type=%u).", osd->osd_nslots, type); } } int osd_call(u_int type, u_int method, void *obj, void *data) { osd_method_t methodfun; int error, i; KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type.")); KASSERT(method < osdm[type].osd_nmethods, ("Invalid method.")); /* * Call this method for every slot that defines it, stopping if an * error is encountered. */ error = 0; sx_slock(&osdm[type].osd_module_lock); for (i = 0; i < osdm[type].osd_ntslots; i++) { /* Hole in the slot map; avoid dereferencing. */ if (osdm[type].osd_destructors[i] == NULL) continue; methodfun = osdm[type].osd_methods[i * osdm[type].osd_nmethods + method]; if (methodfun != NULL && (error = methodfun(obj, data)) != 0) break; } sx_sunlock(&osdm[type].osd_module_lock); return (error); } void osd_exit(u_int type, struct osd *osd) { struct rm_priotracker tracker; u_int i; KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type.")); if (osd->osd_nslots == 0) { KASSERT(osd->osd_slots == NULL, ("Non-null osd_slots.")); /* No OSD attached, just leave. */ return; } rm_rlock(&osdm[type].osd_object_lock, &tracker); for (i = 1; i <= osd->osd_nslots; i++) { if (osdm[type].osd_destructors[i - 1] != NULL) do_osd_del(type, osd, i, 0); else OSD_DEBUG("Unused slot (type=%u, slot=%u).", type, i); } rm_runlock(&osdm[type].osd_object_lock, &tracker); OSD_DEBUG("Object exit (type=%u).", type); } static void osd_init(void *arg __unused) { u_int i; for (i = OSD_FIRST; i <= OSD_LAST; i++) { sx_init(&osdm[i].osd_module_lock, "osd_module"); rm_init(&osdm[i].osd_object_lock, "osd_object"); mtx_init(&osdm[i].osd_list_lock, "osd_list", NULL, MTX_DEF); LIST_INIT(&osdm[i].osd_list); osdm[i].osd_destructors = NULL; osdm[i].osd_ntslots = 0; osdm[i].osd_methods = NULL; } } SYSINIT(osd, SI_SUB_LOCK, SI_ORDER_ANY, osd_init, NULL); diff --git a/sys/sys/osd.h b/sys/sys/osd.h index 498cad5064f9..5d59ce5a3d9a 100644 --- a/sys/sys/osd.h +++ b/sys/sys/osd.h @@ -1,115 +1,115 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2007 Pawel Jakub Dawidek * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _SYS_OSD_H_ #define _SYS_OSD_H_ #include /* * Lock key: * (c) container lock (e.g. jail's pr_mtx) and/or osd_object_lock * (l) osd_list_lock */ struct osd { u_int osd_nslots; /* (c) */ void **osd_slots; /* (c) */ LIST_ENTRY(osd) osd_next; /* (l) */ }; #ifdef _KERNEL #define OSD_THREAD 0 #define OSD_JAIL 1 #define OSD_KHELP 2 #define OSD_FIRST OSD_THREAD #define OSD_LAST OSD_KHELP typedef void (*osd_destructor_t)(void *value); typedef int (*osd_method_t)(void *obj, void *data); int osd_register(u_int type, osd_destructor_t destructor, - osd_method_t *methods); + const osd_method_t *methods); void osd_deregister(u_int type, u_int slot); int osd_set(u_int type, struct osd *osd, u_int slot, void *value); void **osd_reserve(u_int slot); int osd_set_reserved(u_int type, struct osd *osd, u_int slot, void **rsv, void *value); void osd_free_reserved(void **rsv); void *osd_get(u_int type, struct osd *osd, u_int slot); void *osd_get_unlocked(u_int type, struct osd *osd, u_int slot); void osd_del(u_int type, struct osd *osd, u_int slot); int osd_call(u_int type, u_int method, void *obj, void *data); void osd_exit(u_int type, struct osd *osd); #define osd_thread_register(destructor) \ osd_register(OSD_THREAD, (destructor), NULL) #define osd_thread_deregister(slot) \ osd_deregister(OSD_THREAD, (slot)) #define osd_thread_set(td, slot, value) \ osd_set(OSD_THREAD, &(td)->td_osd, (slot), (value)) #define osd_thread_set_reserved(td, slot, rsv, value) \ osd_set_reserved(OSD_THREAD, &(td)->td_osd, (slot), (rsv), (value)) #define osd_thread_get(td, slot) \ osd_get(OSD_THREAD, &(td)->td_osd, (slot)) #define osd_thread_get_unlocked(td, slot) \ osd_get_unlocked(OSD_THREAD, &(td)->td_osd, (slot)) #define osd_thread_del(td, slot) do { \ KASSERT((td) == curthread, ("Not curthread.")); \ osd_del(OSD_THREAD, &(td)->td_osd, (slot)); \ } while (0) #define osd_thread_call(td, method, data) \ osd_call(OSD_THREAD, (method), (td), (data)) #define osd_thread_exit(td) \ osd_exit(OSD_THREAD, &(td)->td_osd) #define osd_jail_register(destructor, methods) \ osd_register(OSD_JAIL, (destructor), (methods)) #define osd_jail_deregister(slot) \ osd_deregister(OSD_JAIL, (slot)) #define osd_jail_set(pr, slot, value) \ osd_set(OSD_JAIL, &(pr)->pr_osd, (slot), (value)) #define osd_jail_set_reserved(pr, slot, rsv, value) \ osd_set_reserved(OSD_JAIL, &(pr)->pr_osd, (slot), (rsv), (value)) #define osd_jail_get(pr, slot) \ osd_get(OSD_JAIL, &(pr)->pr_osd, (slot)) #define osd_jail_get_unlocked(pr, slot) \ osd_get_unlocked(OSD_JAIL, &(pr)->pr_osd, (slot)) #define osd_jail_del(pr, slot) \ osd_del(OSD_JAIL, &(pr)->pr_osd, (slot)) #define osd_jail_call(pr, method, data) \ osd_call(OSD_JAIL, (method), (pr), (data)) #define osd_jail_exit(pr) \ osd_exit(OSD_JAIL, &(pr)->pr_osd) #endif /* _KERNEL */ #endif /* !_SYS_OSD_H_ */