static CMPIStatus
ClassProviderDeleteClass(CMPIClassMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt, const CMPIObjectPath * cop)
{
ClassRegister *cReg;
CMPIConstClass *cl;
int rc;
CMPIStatus st = { CMPI_RC_OK, NULL };
_SFCB_ENTER(TRACE_PROVIDERS, "ClassProviderDeleteClass");
cReg = getNsReg(cop, &rc);
if (cReg == NULL) {
CMPIStatus st = { CMPI_RC_ERR_INVALID_NAMESPACE, NULL };
_SFCB_RETURN(st);
}
char *cn = (char *) cop->ft->getClassName(cop, NULL)->hdl;
cl = getClass(cReg, cn);
if (cl == NULL) {
st.rc = CMPI_RC_ERR_NOT_FOUND;
_SFCB_RETURN(st);
}
UtilList *ul = getChildren(cReg, cn);
if (ul && ul->ft->size(ul)) {
// char *child;
// for (child =(char*)ul->ft->getFirst(ul); child;
// child=(char*)ul->ft->getNext(ul))
// printf("child: %s\n",child);
st.rc = CMPI_RC_ERR_CLASS_HAS_CHILDREN;
_SFCB_RETURN(st);
}
char *pn = (char *) cl->ft->getCharSuperClassName(cl);
cReg->ft->wLock(cReg);
if (pn)
removeChild(cReg, pn, cn);
removeClass(cReg, cn);
cReg->ft->wUnLock(cReg);
_SFCB_RETURN(st);
}
/*!
* \brief Commit class information changing in class container.<br>
* This function is for avoiding trouble with class map.<br>
* At "afterTakeSnapShot", map is copied as shadow copy.<br>
* So crash JVM,
* if we remove item and output map at the same times.
*/
void TClassContainer::commitClassChange(void) {
TClassInfoQueue *list = NULL;
/* Get class container's spin lock. */
spinLockWait(&lockval);
{
/* Remove unloaded class which detected at "pushNewClass". */
while (!unloadedList->empty()) {
TObjectData *target = unloadedList->front();
unloadedList->pop();
/* Free allocated memory. */
free(target->className);
free(target);
}
try {
list = new TClassInfoQueue();
/* Search delete target. */
for (TClassMap::iterator cur = classMap->begin(); cur != classMap->end();
++cur) {
TObjectData *objData = (*cur).second;
/* If class is prepared remove from class container. */
if (unlikely(objData->oldTotalSize == 0 && objData->isRemoved)) {
/*
* If we do removing map item here,
* iterator's relationship will be broken.
* So we store to list. And we remove after iterator loop.
*/
list->push(objData);
}
}
} catch (...) {
/*
* Maybe failed to allocate memory.
* E.g. raise exception at "new", "std::queue<T>::push" or etc..
*/
delete list;
list = NULL;
}
if (likely(list != NULL)) {
/* Remove delete target. */
while (!list->empty()) {
TObjectData *target = list->front();
list->pop();
/* Remove from all containers. */
removeClass(target);
/* Free allocated memory. */
free(target->className);
free(target);
}
}
}
/* Release class container's spin lock. */
spinLockRelease(&lockval);
/* Cleanup. */
delete list;
}
UINT ClassificationData::eraseAllSamplesWithClassLabel(const UINT classLabel){
return removeClass( classLabel );
}
/*!
* \brief Append new-class to container.
* \param klassOop [in] New class oop.
* \param objData [in] Add new class data.
* \return New-class data.<br />
* This value isn't equal param "objData",
* if already registered equivalence class.
*/
TObjectData *TClassContainer::pushNewClass(void *klassOop,
TObjectData *objData) {
TObjectData *existData = NULL;
/* Get class container's spin lock. */
spinLockWait(&lockval);
{
/*
* Jvmti extension event "classUnload" is loose once in a while.
* The event forget callback occasionally when class unloading.
* So we need to check klassOop that was doubling.
*/
/* Check klassOop doubling. */
TClassMap::iterator it = classMap->find(klassOop);
if (likely(it != classMap->end())) {
/* Store data to return value as result. */
TObjectData *expectData = (*it).second;
if (likely(expectData != NULL)) {
/* If adding class data is already exists. */
if (unlikely(expectData->className != NULL &&
strcmp(objData->className, expectData->className) == 0 &&
objData->clsLoaderId == expectData->clsLoaderId)) {
/* Return existing data on map. */
existData = expectData;
} else {
/* klass oop is doubling for another class. */
removeClass(expectData);
try {
unloadedList->push(expectData);
} catch (...) {
/*
* We try to continue running without crash
* even if failed to allocate memory.
*/
}
}
}
}
if (likely(existData == NULL)) {
try {
/* Append class data. */
(*classMap)[klassOop] = objData;
} catch (...) {
/*
* Maybe failed to allocate memory at "std::map::operator[]".
*/
}
}
}
/* Release class container's spin lock. */
spinLockRelease(&lockval);
/* If already exist class data. */
if (unlikely(existData != NULL)) {
return existData;
}
/* Get spin lock of containers queue. */
spinLockWait(&queueLock);
{
/* Broadcast to each local container. */
for (TLocalClassContainer::iterator it = localContainers.begin();
it != localContainers.end(); it++) {
(*it)->pushNewClass(klassOop, objData);
}
}
/* Release spin lock of containers queue. */
spinLockRelease(&queueLock);
return objData;
}
