d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MFC r297367:

Browse Source 
Move the various per-type arrays of OSD data into a single structure array.

MFC r297422:

  Add osd_reserve() and osd_set_reserved(), which allow M_WAITOK allocation
  of an OSD array.
This commit is contained in:
jamie 2016-04-30 04:01:22 +00:00
parent 0621c28d20
commit 8f24180547
3 changed files with 222 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
share/man/man9/osd.9
View File

@ -25,7 +25,7 @@
.\"
.\" $FreeBSD$
.\"
.Dd January 5, 2011
.Dd March 30, 2016
.Dt OSD 9
.Os
.Sh NAME
@ -33,6 +33,9 @@
.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 ,
@ -63,6 +66,22 @@
.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"
@ -198,6 +217,15 @@ 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
@ -324,6 +352,24 @@ 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
@ -359,15 +405,27 @@ the kernel including most fast paths.
returns the slot identifier for the newly registered data type.
.Pp
.Fn osd_set
returns zero on success or ENOMEM if the specified type/slot identifier pair
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.
which failed
.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,

265
sys/kern/kern_osd.c
View File

@ -44,6 +44,23 @@ __FBSDID("$FreeBSD$");
/* 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;
@ -62,25 +79,12 @@ static void do_osd_del(u_int type, struct osd *osd, u_int slot,
int list_locked);
/*
* Lists of objects with OSD.
*
* Lock key:
* (m) osd_module_lock
* (o) osd_object_lock
* (l) osd_list_lock
* List of objects with OSD.
*/
static LIST_HEAD(, osd) osd_list[OSD_LAST + 1]; /* (m) */
static osd_method_t *osd_methods[OSD_LAST + 1]; /* (m) */
static u_int osd_nslots[OSD_LAST + 1]; /* (m) */
static osd_destructor_t *osd_destructors[OSD_LAST + 1]; /* (o) */
static const u_int osd_nmethods[OSD_LAST + 1] = {
[OSD_JAIL] = PR_MAXMETHOD,
struct osd_master osdm[OSD_LAST + 1] = {
[OSD_JAIL] = { .osd_nmethods = PR_MAXMETHOD },
};
static struct sx osd_module_lock[OSD_LAST + 1];
static struct rmlock osd_object_lock[OSD_LAST + 1];
static struct mtx osd_list_lock[OSD_LAST + 1];
static void
osd_default_destructor(void *value __unused)
{
@ -102,12 +106,12 @@ osd_register(u_int type, osd_destructor_t destructor, osd_method_t *methods)
if (destructor == NULL)
destructor = osd_default_destructor;
sx_xlock(&osd_module_lock[type]);
sx_xlock(&osdm[type].osd_module_lock);
/*
* First, we try to find unused slot.
*/
for (i = 0; i < osd_nslots[type]; i++) {
if (osd_destructors[type][i] == NULL) {
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);
break;
@ -116,31 +120,31 @@ osd_register(u_int type, osd_destructor_t destructor, osd_method_t *methods)
/*
* If no unused slot was found, allocate one.
*/
if (i == osd_nslots[type]) {
osd_nslots[type]++;
if (osd_nmethods[type] != 0)
osd_methods[type] = realloc(osd_methods[type],
sizeof(osd_method_t) * osd_nslots[type] *
osd_nmethods[type], M_OSD, M_WAITOK);
newptr = malloc(sizeof(osd_destructor_t) * osd_nslots[type],
M_OSD, M_WAITOK);
rm_wlock(&osd_object_lock[type]);
bcopy(osd_destructors[type], newptr,
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(osd_destructors[type], M_OSD);
osd_destructors[type] = newptr;
rm_wunlock(&osd_object_lock[type]);
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);
}
osd_destructors[type][i] = destructor;
if (osd_nmethods[type] != 0) {
for (m = 0; m < osd_nmethods[type]; m++)
osd_methods[type][i * osd_nmethods[type] + m] =
methods != NULL ? methods[m] : NULL;
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(&osd_module_lock[type]);
sx_xunlock(&osdm[type].osd_module_lock);
return (i + 1);
}
@ -151,105 +155,142 @@ osd_deregister(u_int type, u_int slot)
KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
KASSERT(slot > 0, ("Invalid slot."));
KASSERT(osd_destructors[type][slot - 1] != NULL, ("Unused slot."));
KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
sx_xlock(&osd_module_lock[type]);
rm_wlock(&osd_object_lock[type]);
sx_xlock(&osdm[type].osd_module_lock);
rm_wlock(&osdm[type].osd_object_lock);
/*
* Free all OSD for the given slot.
*/
mtx_lock(&osd_list_lock[type]);
LIST_FOREACH_SAFE(osd, &osd_list[type], osd_next, tosd)
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(&osd_list_lock[type]);
mtx_unlock(&osdm[type].osd_list_lock);
/*
* Set destructor to NULL to free the slot.
*/
osd_destructors[type][slot - 1] = NULL;
if (slot == osd_nslots[type]) {
osd_nslots[type]--;
osd_destructors[type] = realloc(osd_destructors[type],
sizeof(osd_destructor_t) * osd_nslots[type], M_OSD,
osdm[type].osd_destructors[slot - 1] = NULL;
if (slot == osdm[type].osd_ntslots) {
osdm[type].osd_ntslots--;
osdm[type].osd_destructors = realloc(osdm[type].osd_destructors,
sizeof(osd_destructor_t) * osdm[type].osd_ntslots, M_OSD,
M_NOWAIT | M_ZERO);
if (osd_nmethods[type] != 0)
osd_methods[type] = realloc(osd_methods[type],
sizeof(osd_method_t) * osd_nslots[type] *
osd_nmethods[type], M_OSD, M_NOWAIT | M_ZERO);
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_NOWAIT | M_ZERO);
/*
* We always reallocate to smaller size, so we assume it will
* always succeed.
*/
KASSERT(osd_destructors[type] != NULL &&
(osd_nmethods[type] == 0 || osd_methods[type] != NULL),
("realloc() failed"));
KASSERT(osdm[type].osd_destructors != NULL &&
(osdm[type].osd_nmethods == 0 ||
osdm[type].osd_methods != NULL), ("realloc() failed"));
OSD_DEBUG("Deregistration of the last slot (type=%u, slot=%u).",
type, slot);
} else {
OSD_DEBUG("Slot deregistration (type=%u, slot=%u).",
type, slot);
}
rm_wunlock(&osd_object_lock[type]);
sx_xunlock(&osd_module_lock[type]);
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."));
KASSERT(osd_destructors[type][slot - 1] != NULL, ("Unused slot."));
KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
rm_rlock(&osd_object_lock[type], &tracker);
rm_rlock(&osdm[type].osd_object_lock, &tracker);
if (slot > osd->osd_nslots) {
void *newptr;
if (value == NULL) {
OSD_DEBUG(
"Not allocating null slot (type=%u, slot=%u).",
type, slot);
rm_runlock(&osd_object_lock[type], &tracker);
rm_runlock(&osdm[type].osd_object_lock, &tracker);
if (rsv)
osd_free_reserved(rsv);
return (0);
} else if (osd->osd_nslots == 0) {
/*
* First OSD for this object, so we need to allocate
* space and put it onto the list.
*/
osd->osd_slots = malloc(sizeof(void *) * slot, M_OSD,
M_NOWAIT | M_ZERO);
if (osd->osd_slots == NULL) {
rm_runlock(&osd_object_lock[type], &tracker);
return (ENOMEM);
}
osd->osd_nslots = slot;
mtx_lock(&osd_list_lock[type]);
LIST_INSERT_HEAD(&osd_list[type], osd, osd_next);
mtx_unlock(&osd_list_lock[type]);
OSD_DEBUG("Setting first slot (type=%u).", type);
} else {
void *newptr;
}
/*
* Too few slots allocated here, so we need to extend or create
* the array.
*/
if (rsv) {
/*
* Too few slots allocated here, needs to extend
* the array.
* 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(&osd_object_lock[type], &tracker);
rm_runlock(&osdm[type].osd_object_lock,
&tracker);
return (ENOMEM);
}
osd->osd_slots = newptr;
osd->osd_nslots = slot;
OSD_DEBUG("Growing slots array (type=%u).", type);
}
}
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(&osd_object_lock[type], &tracker);
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(u_int type, struct osd *osd, u_int slot)
{
@ -258,9 +299,9 @@ osd_get(u_int type, struct osd *osd, u_int slot)
KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
KASSERT(slot > 0, ("Invalid slot."));
KASSERT(osd_destructors[type][slot - 1] != NULL, ("Unused slot."));
KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
rm_rlock(&osd_object_lock[type], &tracker);
rm_rlock(&osdm[type].osd_object_lock, &tracker);
if (slot > osd->osd_nslots) {
value = NULL;
OSD_DEBUG("Slot doesn't exist (type=%u, slot=%u).", type, slot);
@ -269,7 +310,7 @@ osd_get(u_int type, struct osd *osd, u_int slot)
OSD_DEBUG("Returning slot value (type=%u, slot=%u, value=%p).",
type, slot, value);
}
rm_runlock(&osd_object_lock[type], &tracker);
rm_runlock(&osdm[type].osd_object_lock, &tracker);
return (value);
}
@ -278,9 +319,9 @@ osd_del(u_int type, struct osd *osd, u_int slot)
{
struct rm_priotracker tracker;
rm_rlock(&osd_object_lock[type], &tracker);
rm_rlock(&osdm[type].osd_object_lock, &tracker);
do_osd_del(type, osd, slot, 0);
rm_runlock(&osd_object_lock[type], &tracker);
rm_runlock(&osdm[type].osd_object_lock, &tracker);
}
static void
@ -290,7 +331,7 @@ do_osd_del(u_int type, struct osd *osd, u_int slot, int list_locked)
KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
KASSERT(slot > 0, ("Invalid slot."));
KASSERT(osd_destructors[type][slot - 1] != NULL, ("Unused slot."));
KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
OSD_DEBUG("Deleting slot (type=%u, slot=%u).", type, slot);
@ -299,7 +340,7 @@ do_osd_del(u_int type, struct osd *osd, u_int slot, int list_locked)
return;
}
if (osd->osd_slots[slot - 1] != NULL) {
osd_destructors[type][slot - 1](osd->osd_slots[slot - 1]);
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--) {
@ -313,10 +354,10 @@ do_osd_del(u_int type, struct osd *osd, u_int slot, int list_locked)
/* No values left for this object. */
OSD_DEBUG("No more slots left (type=%u).", type);
if (!list_locked)
mtx_lock(&osd_list_lock[type]);
mtx_lock(&osdm[type].osd_list_lock);
LIST_REMOVE(osd, osd_next);
if (!list_locked)
mtx_unlock(&osd_list_lock[type]);
mtx_unlock(&osdm[type].osd_list_lock);
free(osd->osd_slots, M_OSD);
osd->osd_slots = NULL;
osd->osd_nslots = 0;
@ -342,21 +383,21 @@ osd_call(u_int type, u_int method, void *obj, void *data)
int error, i;
KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
KASSERT(method < osd_nmethods[type], ("Invalid method."));
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(&osd_module_lock[type]);
for (i = 0; i < osd_nslots[type]; i++) {
methodfun =
osd_methods[type][i * osd_nmethods[type] + method];
sx_slock(&osdm[type].osd_module_lock);
for (i = 0; i < osdm[type].osd_ntslots; i++) {
methodfun = osdm[type].osd_methods[i * osdm[type].osd_nmethods +
method];
if (methodfun != NULL && (error = methodfun(obj, data)) != 0)
break;
}
sx_sunlock(&osd_module_lock[type]);
sx_sunlock(&osdm[type].osd_module_lock);
return (error);
}
@ -374,14 +415,14 @@ osd_exit(u_int type, struct osd *osd)
return;
}
rm_rlock(&osd_object_lock[type], &tracker);
rm_rlock(&osdm[type].osd_object_lock, &tracker);
for (i = 1; i <= osd->osd_nslots; i++) {
if (osd_destructors[type][i - 1] != NULL)
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(&osd_object_lock[type], &tracker);
rm_runlock(&osdm[type].osd_object_lock, &tracker);
OSD_DEBUG("Object exit (type=%u).", type);
}
@ -391,13 +432,13 @@ osd_init(void *arg __unused)
u_int i;
for (i = OSD_FIRST; i <= OSD_LAST; i++) {
osd_nslots[i] = 0;
LIST_INIT(&osd_list[i]);
sx_init(&osd_module_lock[i], "osd_module");
rm_init(&osd_object_lock[i], "osd_object");
mtx_init(&osd_list_lock[i], "osd_list", NULL, MTX_DEF);
osd_destructors[i] = NULL;
osd_methods[i] = NULL;
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);

8
sys/sys/osd.h
View File

@ -59,6 +59,10 @@ int osd_register(u_int type, osd_destructor_t destructor,
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_del(u_int type, struct osd *osd, u_int slot);
int osd_call(u_int type, u_int method, void *obj, void *data);
@ -71,6 +75,8 @@ void osd_exit(u_int type, struct osd *osd);
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_del(td, slot) do { \
@ -88,6 +94,8 @@ void osd_exit(u_int type, struct osd *osd);
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_del(pr, slot) \