int osd_set(u_int type, struct osd *osd, u_int slot, 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.")); rm_rlock(&osd_object_lock[type], &tracker); if (slot > osd->osd_nslots) { if (value == NULL) { OSD_DEBUG( "Not allocating null slot (type=%u, slot=%u).", type, slot); rm_runlock(&osd_object_lock[type], &tracker); 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, needs to extend * the array. */ newptr = realloc(osd->osd_slots, sizeof(void *) * slot, M_OSD, M_NOWAIT | M_ZERO); if (newptr == NULL) { rm_runlock(&osd_object_lock[type], &tracker); return (ENOMEM); } osd->osd_slots = newptr; osd->osd_nslots = slot; OSD_DEBUG("Growing slots array (type=%u).", type); } } 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); return (0); }
int osd_register(u_int type, osd_destructor_t destructor, 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(&osd_module_lock[type]); /* * First, we try to find unused slot. */ for (i = 0; i < osd_nslots[type]; i++) { if (osd_destructors[type][i] == NULL) { OSD_DEBUG("Unused slot found (type=%u, slot=%u).", type, i); break; } } /* * 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, sizeof(osd_destructor_t) * i); free(osd_destructors[type], M_OSD); osd_destructors[type] = newptr; rm_wunlock(&osd_object_lock[type]); 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; } sx_xunlock(&osd_module_lock[type]); return (i + 1); }
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(osd_destructors[type][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) { osd_destructors[type][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(&osd_list_lock[type]); LIST_REMOVE(osd, osd_next); if (!list_locked) mtx_unlock(&osd_list_lock[type]); 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); } }
void osd_free_reserved(void **rsv) { OSD_DEBUG("Discarding reserved slot array."); free(rsv, M_OSD); }
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.")); KASSERT(osd_destructors[type][slot - 1] != NULL, ("Unused slot.")); sx_xlock(&osd_module_lock[type]); rm_wlock(&osd_object_lock[type]); /* * Free all OSD for the given slot. */ mtx_lock(&osd_list_lock[type]); LIST_FOREACH_SAFE(osd, &osd_list[type], osd_next, tosd) do_osd_del(type, osd, slot, 1); mtx_unlock(&osd_list_lock[type]); /* * 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, 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); /* * 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")); 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]); }
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.")); KASSERT(osd_destructors[type][slot - 1] != NULL, ("Unused slot.")); rm_rlock(&osd_object_lock[type], &tracker); if (slot > osd->osd_nslots) { value = NULL; OSD_DEBUG("Slot doesn't exist (type=%u, slot=%u).", type, slot); } else { value = osd->osd_slots[slot - 1]; OSD_DEBUG("Returning slot value (type=%u, slot=%u, value=%p).", type, slot, value); } rm_runlock(&osd_object_lock[type], &tracker); return (value); }
bool OsdMesh::Create(OsdHbrMesh *hbrMesh, int level, int kernel, int exact, std::vector<int> * remap) { if (_dispatcher) delete _dispatcher; _dispatcher = OsdKernelDispatcher::CreateKernelDispatcher(level, kernel); if (not _dispatcher) { OSD_ERROR("Unknown kernel %d\n", kernel); return false; } _level = level; _exact = exact; // create Far mesh OSD_DEBUG("Create MeshFactory\n"); FarMeshFactory<OsdVertex> meshFactory(hbrMesh, _level); _farMesh = meshFactory.Create(_dispatcher); OSD_DEBUG("PREP: NumCoarseVertex = %d\n", _farMesh->GetNumCoarseVertices()); OSD_DEBUG("PREP: NumVertex = %d\n", _farMesh->GetNumVertices()); createTables( _farMesh->GetSubdivision() ); FarVertexEditTables<OsdVertex> const *editTables = _farMesh->GetVertexEdit(); if (editTables) createEditTables( editTables ); // copy the remapping table if the client needs to remap vertex indices from // Osd to Hbr for comparison / regression purposes. if (remap) (*remap)=meshFactory.GetRemappingTable(); return true; }
int osd_auto_detect_ver(struct osd_dev *od, void *caps) { int ret; /* Auto-detect the osd version */ ret = _osd_print_system_info(od, caps); if (ret) { osd_dev_set_ver(od, OSD_VER1); OSD_DEBUG("converting to OSD1\n"); ret = _osd_print_system_info(od, caps); } return ret; }
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(&osd_object_lock[type], &tracker); for (i = 1; i <= osd->osd_nslots; i++) { if (osd_destructors[type][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); OSD_DEBUG("Object exit (type=%u).", type); }
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(osdm[type].osd_destructors[slot - 1] != NULL, ("Unused slot.")); 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(&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); }