sys/kern/kern_osd.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   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 AUTHORS 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 AUTHORS 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/systm.h>
  35 #include <sys/sysctl.h>
  36 #include <sys/errno.h>
  37 #include <sys/jail.h>
  38 #include <sys/malloc.h>
  39 #include <sys/lock.h>
  40 #include <sys/mutex.h>
  41 #include <sys/rmlock.h>
  42 #include <sys/sx.h>
  43 #include <sys/queue.h>
  44 #include <sys/proc.h>
  45 #include <sys/osd.h>
  46
  47 /* OSD (Object Specific Data) */
  48
  49 /*
  50  * Lock key:
  51  *  (m) osd_module_lock
  52  *  (o) osd_object_lock
  53  *  (l) osd_list_lock
  54  */
  55 struct osd_master {
  56         struct sx                osd_module_lock;
  57         struct rmlock            osd_object_lock;
  58         struct mtx               osd_list_lock;
  59         LIST_HEAD(, osd)         osd_list;              /* (l) */
  60         osd_destructor_t        *osd_destructors;       /* (o) */
  61         osd_method_t            *osd_methods;           /* (m) */
  62         u_int                    osd_ntslots;           /* (m) */
  63         const u_int              osd_nmethods;
  64 };
  65
  66 static MALLOC_DEFINE(M_OSD, "osd", "Object Specific Data");
  67
  68 static int osd_debug = 0;
  69 SYSCTL_INT(_debug, OID_AUTO, osd, CTLFLAG_RWTUN, &osd_debug, 0, "OSD debug level");
  70
  71 #define OSD_DEBUG(...)  do {                                            \
  72         if (osd_debug) {                                                \
  73                 printf("OSD (%s:%u): ", __func__, __LINE__);            \
  74                 printf(__VA_ARGS__);                                    \
  75                 printf("\n");                                           \
  76         }                                                               \
  77 } while (0)
  78
  79 static void do_osd_del(u_int type, struct osd *osd, u_int slot,
  80     int list_locked);
  81
  82 /*
  83  * List of objects with OSD.
  84  */
  85 struct osd_master osdm[OSD_LAST + 1] = {
  86         [OSD_JAIL] = { .osd_nmethods = PR_MAXMETHOD },
  87 };
  88
  89 static void
  90 osd_default_destructor(void *value __unused)
  91 {
  92         /* Do nothing. */
  93 }
  94
  95 int
  96 osd_register(u_int type, osd_destructor_t destructor, osd_method_t *methods)
  97 {
  98         void *newptr;
  99         u_int i, m;
 100
 101         KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
 102
 103         /*
 104          * If no destructor is given, use default one. We need to use some
 105          * destructor, because NULL destructor means unused slot.
 106          */
 107         if (destructor == NULL)
 108                 destructor = osd_default_destructor;
 109
 110         sx_xlock(&osdm[type].osd_module_lock);
 111         /*
 112          * First, we try to find unused slot.
 113          */
 114         for (i = 0; i < osdm[type].osd_ntslots; i++) {
 115                 if (osdm[type].osd_destructors[i] == NULL) {
 116                         OSD_DEBUG("Unused slot found (type=%u, slot=%u).",
 117                             type, i);
 118                         break;
 119                 }
 120         }
 121         /*
 122          * If no unused slot was found, allocate one.
 123          */
 124         if (i == osdm[type].osd_ntslots) {
 125                 osdm[type].osd_ntslots++;
 126                 if (osdm[type].osd_nmethods != 0)
 127                         osdm[type].osd_methods = realloc(osdm[type].osd_methods,
 128                             sizeof(osd_method_t) * osdm[type].osd_ntslots *
 129                             osdm[type].osd_nmethods, M_OSD, M_WAITOK);
 130                 newptr = malloc(sizeof(osd_destructor_t) *
 131                     osdm[type].osd_ntslots, M_OSD, M_WAITOK);
 132                 rm_wlock(&osdm[type].osd_object_lock);
 133                 bcopy(osdm[type].osd_destructors, newptr,
 134                     sizeof(osd_destructor_t) * i);
 135                 free(osdm[type].osd_destructors, M_OSD);
 136                 osdm[type].osd_destructors = newptr;
 137                 rm_wunlock(&osdm[type].osd_object_lock);
 138                 OSD_DEBUG("New slot allocated (type=%u, slot=%u).",
 139                     type, i + 1);
 140         }
 141
 142         osdm[type].osd_destructors[i] = destructor;
 143         if (osdm[type].osd_nmethods != 0) {
 144                 for (m = 0; m < osdm[type].osd_nmethods; m++)
 145                         osdm[type].osd_methods[i * osdm[type].osd_nmethods + m]
 146                             = methods != NULL ? methods[m] : NULL;
 147         }
 148         sx_xunlock(&osdm[type].osd_module_lock);
 149         return (i + 1);
 150 }
 151
 152 void
 153 osd_deregister(u_int type, u_int slot)
 154 {
 155         struct osd *osd, *tosd;
 156
 157         KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
 158         KASSERT(slot > 0, ("Invalid slot."));
 159
 160         sx_xlock(&osdm[type].osd_module_lock);
 161         rm_wlock(&osdm[type].osd_object_lock);
 162         KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
 163
 164         /*
 165          * Free all OSD for the given slot.
 166          */
 167         mtx_lock(&osdm[type].osd_list_lock);
 168         LIST_FOREACH_SAFE(osd, &osdm[type].osd_list, osd_next, tosd)
 169                 do_osd_del(type, osd, slot, 1);
 170         mtx_unlock(&osdm[type].osd_list_lock);
 171         /*
 172          * Set destructor to NULL to free the slot.
 173          */
 174         osdm[type].osd_destructors[slot - 1] = NULL;
 175         if (slot == osdm[type].osd_ntslots) {
 176                 osdm[type].osd_ntslots--;
 177                 osdm[type].osd_destructors = realloc(osdm[type].osd_destructors,
 178                     sizeof(osd_destructor_t) * osdm[type].osd_ntslots, M_OSD,
 179                     M_NOWAIT | M_ZERO);
 180                 if (osdm[type].osd_nmethods != 0)
 181                         osdm[type].osd_methods = realloc(osdm[type].osd_methods,
 182                             sizeof(osd_method_t) * osdm[type].osd_ntslots *
 183                             osdm[type].osd_nmethods, M_OSD, M_NOWAIT | M_ZERO);
 184                 /*
 185                  * We always reallocate to smaller size, so we assume it will
 186                  * always succeed.
 187                  */
 188                 KASSERT(osdm[type].osd_destructors != NULL &&
 189                     (osdm[type].osd_nmethods == 0 ||
 190                      osdm[type].osd_methods != NULL), ("realloc() failed"));
 191                 OSD_DEBUG("Deregistration of the last slot (type=%u, slot=%u).",
 192                     type, slot);
 193         } else {
 194                 OSD_DEBUG("Slot deregistration (type=%u, slot=%u).",
 195                     type, slot);
 196         }
 197         rm_wunlock(&osdm[type].osd_object_lock);
 198         sx_xunlock(&osdm[type].osd_module_lock);
 199 }
 200
 201 int
 202 osd_set(u_int type, struct osd *osd, u_int slot, void *value)
 203 {
 204
 205         return (osd_set_reserved(type, osd, slot, NULL, value));
 206 }
 207
 208 void **
 209 osd_reserve(u_int slot)
 210 {
 211
 212         KASSERT(slot > 0, ("Invalid slot."));
 213
 214         OSD_DEBUG("Reserving slot array (slot=%u).", slot);
 215         return (malloc(sizeof(void *) * slot, M_OSD, M_WAITOK | M_ZERO));
 216 }
 217
 218 int
 219 osd_set_reserved(u_int type, struct osd *osd, u_int slot, void **rsv,
 220     void *value)
 221 {
 222         struct rm_priotracker tracker;
 223
 224         KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
 225         KASSERT(slot > 0, ("Invalid slot."));
 226
 227         rm_rlock(&osdm[type].osd_object_lock, &tracker);
 228         KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
 229
 230         if (slot > osd->osd_nslots) {
 231                 void **newptr;
 232
 233                 if (value == NULL) {
 234                         OSD_DEBUG(
 235                             "Not allocating null slot (type=%u, slot=%u).",
 236                             type, slot);
 237                         rm_runlock(&osdm[type].osd_object_lock, &tracker);
 238                         if (rsv)
 239                                 osd_free_reserved(rsv);
 240                         return (0);
 241                 }
 242
 243                 /*
 244                  * Too few slots allocated here, so we need to extend or create
 245                  * the array.
 246                  */
 247                 if (rsv) {
 248                         /*
 249                          * Use the reserve passed in (assumed to be
 250                          * the right size).
 251                          */
 252                         newptr = rsv;
 253                         if (osd->osd_nslots != 0) {
 254                                 memcpy(newptr, osd->osd_slots,
 255                                     sizeof(void *) * osd->osd_nslots);
 256                                 free(osd->osd_slots, M_OSD);
 257                         }
 258                 } else {
 259                         newptr = realloc(osd->osd_slots, sizeof(void *) * slot,
 260                             M_OSD, M_NOWAIT | M_ZERO);
 261                         if (newptr == NULL) {
 262                                 rm_runlock(&osdm[type].osd_object_lock,
 263                                     &tracker);
 264                                 return (ENOMEM);
 265                         }
 266                 }
 267                 if (osd->osd_nslots == 0) {
 268                         /*
 269                          * First OSD for this object, so we need to put it
 270                          * onto the list.
 271                          */
 272                         mtx_lock(&osdm[type].osd_list_lock);
 273                         LIST_INSERT_HEAD(&osdm[type].osd_list, osd, osd_next);
 274                         mtx_unlock(&osdm[type].osd_list_lock);
 275                         OSD_DEBUG("Setting first slot (type=%u).", type);
 276                 } else
 277                         OSD_DEBUG("Growing slots array (type=%u).", type);
 278                 osd->osd_slots = newptr;
 279                 osd->osd_nslots = slot;
 280         } else if (rsv)
 281                 osd_free_reserved(rsv);
 282         OSD_DEBUG("Setting slot value (type=%u, slot=%u, value=%p).", type,
 283             slot, value);
 284         osd->osd_slots[slot - 1] = value;
 285         rm_runlock(&osdm[type].osd_object_lock, &tracker);
 286         return (0);
 287 }
 288
 289 void
 290 osd_free_reserved(void **rsv)
 291 {
 292
 293         OSD_DEBUG("Discarding reserved slot array.");
 294         free(rsv, M_OSD);
 295 }
 296
 297 void *
 298 osd_get(u_int type, struct osd *osd, u_int slot)
 299 {
 300         struct rm_priotracker tracker;
 301         void *value;
 302
 303         KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
 304         KASSERT(slot > 0, ("Invalid slot."));
 305
 306         rm_rlock(&osdm[type].osd_object_lock, &tracker);
 307         KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
 308
 309         if (slot > osd->osd_nslots) {
 310                 value = NULL;
 311                 OSD_DEBUG("Slot doesn't exist (type=%u, slot=%u).", type, slot);
 312         } else {
 313                 value = osd->osd_slots[slot - 1];
 314                 OSD_DEBUG("Returning slot value (type=%u, slot=%u, value=%p).",
 315                     type, slot, value);
 316         }
 317         rm_runlock(&osdm[type].osd_object_lock, &tracker);
 318         return (value);
 319 }
 320
 321 void
 322 osd_del(u_int type, struct osd *osd, u_int slot)
 323 {
 324         struct rm_priotracker tracker;
 325
 326         rm_rlock(&osdm[type].osd_object_lock, &tracker);
 327         do_osd_del(type, osd, slot, 0);
 328         rm_runlock(&osdm[type].osd_object_lock, &tracker);
 329 }
 330
 331 static void
 332 do_osd_del(u_int type, struct osd *osd, u_int slot, int list_locked)
 333 {
 334         int i;
 335
 336         KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
 337         KASSERT(slot > 0, ("Invalid slot."));
 338         KASSERT(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot."));
 339
 340         OSD_DEBUG("Deleting slot (type=%u, slot=%u).", type, slot);
 341
 342         if (slot > osd->osd_nslots) {
 343                 OSD_DEBUG("Slot doesn't exist (type=%u, slot=%u).", type, slot);
 344                 return;
 345         }
 346         if (osd->osd_slots[slot - 1] != NULL) {
 347                 osdm[type].osd_destructors[slot - 1](osd->osd_slots[slot - 1]);
 348                 osd->osd_slots[slot - 1] = NULL;
 349         }
 350         for (i = osd->osd_nslots - 1; i >= 0; i--) {
 351                 if (osd->osd_slots[i] != NULL) {
 352                         OSD_DEBUG("Slot still has a value (type=%u, slot=%u).",
 353                             type, i + 1);
 354                         break;
 355                 }
 356         }
 357         if (i == -1) {
 358                 /* No values left for this object. */
 359                 OSD_DEBUG("No more slots left (type=%u).", type);
 360                 if (!list_locked)
 361                         mtx_lock(&osdm[type].osd_list_lock);
 362                 LIST_REMOVE(osd, osd_next);
 363                 if (!list_locked)
 364                         mtx_unlock(&osdm[type].osd_list_lock);
 365                 free(osd->osd_slots, M_OSD);
 366                 osd->osd_slots = NULL;
 367                 osd->osd_nslots = 0;
 368         } else if (slot == osd->osd_nslots) {
 369                 /* This was the last slot. */
 370                 osd->osd_slots = realloc(osd->osd_slots,
 371                     sizeof(void *) * (i + 1), M_OSD, M_NOWAIT | M_ZERO);
 372                 /*
 373                  * We always reallocate to smaller size, so we assume it will
 374                  * always succeed.
 375                  */
 376                 KASSERT(osd->osd_slots != NULL, ("realloc() failed"));
 377                 osd->osd_nslots = i + 1;
 378                 OSD_DEBUG("Reducing slots array to %u (type=%u).",
 379                     osd->osd_nslots, type);
 380         }
 381 }
 382
 383 int
 384 osd_call(u_int type, u_int method, void *obj, void *data)
 385 {
 386         osd_method_t methodfun;
 387         int error, i;
 388
 389         KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
 390         KASSERT(method < osdm[type].osd_nmethods, ("Invalid method."));
 391
 392         /*
 393          * Call this method for every slot that defines it, stopping if an
 394          * error is encountered.
 395          */
 396         error = 0;
 397         sx_slock(&osdm[type].osd_module_lock);
 398         for (i = 0; i < osdm[type].osd_ntslots; i++) {
 399                 methodfun = osdm[type].osd_methods[i * osdm[type].osd_nmethods +
 400                     method];
 401                 if (methodfun != NULL && (error = methodfun(obj, data)) != 0)
 402                         break;
 403         }
 404         sx_sunlock(&osdm[type].osd_module_lock);
 405         return (error);
 406 }
 407
 408 void
 409 osd_exit(u_int type, struct osd *osd)
 410 {
 411         struct rm_priotracker tracker;
 412         u_int i;
 413
 414         KASSERT(type >= OSD_FIRST && type <= OSD_LAST, ("Invalid type."));
 415
 416         if (osd->osd_nslots == 0) {
 417                 KASSERT(osd->osd_slots == NULL, ("Non-null osd_slots."));
 418                 /* No OSD attached, just leave. */
 419                 return;
 420         }
 421
 422         rm_rlock(&osdm[type].osd_object_lock, &tracker);
 423         for (i = 1; i <= osd->osd_nslots; i++) {
 424                 if (osdm[type].osd_destructors[i - 1] != NULL)
 425                         do_osd_del(type, osd, i, 0);
 426                 else
 427                         OSD_DEBUG("Unused slot (type=%u, slot=%u).", type, i);
 428         }
 429         rm_runlock(&osdm[type].osd_object_lock, &tracker);
 430         OSD_DEBUG("Object exit (type=%u).", type);
 431 }
 432
 433 static void
 434 osd_init(void *arg __unused)
 435 {
 436         u_int i;
 437
 438         for (i = OSD_FIRST; i <= OSD_LAST; i++) {
 439                 sx_init(&osdm[i].osd_module_lock, "osd_module");
 440                 rm_init(&osdm[i].osd_object_lock, "osd_object");
 441                 mtx_init(&osdm[i].osd_list_lock, "osd_list", NULL, MTX_DEF);
 442                 LIST_INIT(&osdm[i].osd_list);
 443                 osdm[i].osd_destructors = NULL;
 444                 osdm[i].osd_ntslots = 0;
 445                 osdm[i].osd_methods = NULL;
 446         }
 447 }
 448 SYSINIT(osd, SI_SUB_LOCK, SI_ORDER_ANY, osd_init, NULL);