/* Destroy
* destroy
*/
LIB_EXPORT rc_t CC KCipherManagerDestroy ( KCipherManager *self )
{
rc_t rc = 0;
if ( self == NULL )
rc = RC ( rcKrypto, rcMgr, rcDestroying, rcSelf, rcNull );
else
{
if (self == singleton . ptr)
{
KCipherManager * reread;
reread = atomic_test_and_set_ptr (&singleton, NULL, self);
/* ignore results: just going for guaranteed atomicity though might not need it */
( void ) reread;
}
/* no return value */
KRefcountWhack (&self->refcount, kciphermanager_classname);
rc = KLockRelease (self->lock);
free (self);
}
return rc;
}
LIB_EXPORT
rc_t CC
XFSTreeDepotDispose ( const struct XFSTreeDepot * self )
{
rc_t RCt;
struct XFSTree * Tree;
KLock * mutabor;
RCt = 0;
Tree = NULL;
mutabor = NULL;
/*
printf ( " |<- DepotDispose ( 0x%p )\n", ( void * ) self );
*/
if ( self == 0 ) {
return 0;
}
/* That is not thread safe method :lol: */
Tree = ( struct XFSTree * ) self -> Tree;
mutabor = self -> mutabor;
free ( ( struct XFSTreeDepot * ) self );
XFSTreeRelease ( Tree );
KLockRelease ( mutabor );
return RCt;
} /* XFSTreeDepotDispose () */
/* Make
* create an empty queue object
*
* "capacity" [ IN ] - minimum queue length
* always expands to a power of 2, i.e. providing
* a length of 10 will result in a length of 16.
*/
LIB_EXPORT rc_t CC KQueueMake ( KQueue **qp, uint32_t capacity )
{
rc_t rc;
if ( qp == NULL )
rc = RC ( rcCont, rcQueue, rcConstructing, rcParam, rcNull );
else
{
KQueue *q;
uint32_t cap = 1;
while ( cap < capacity )
cap += cap;
q = malloc ( sizeof * q - sizeof q -> buffer + cap * sizeof q -> buffer [ 0 ] );
if ( q == NULL )
rc = RC ( rcCont, rcQueue, rcConstructing, rcMemory, rcExhausted );
else
{
rc = KSemaphoreMake ( & q -> rc, 0 );
if ( rc == 0 )
{
rc = KSemaphoreMake ( & q -> wc, cap );
if ( rc == 0 )
{
rc = KLockMake ( & q -> rl );
if ( rc == 0 )
{
rc = KLockMake ( & q -> wl );
if ( rc == 0 )
{
q -> capacity = cap;
q -> bmask = cap - 1;
q -> imask = ( cap + cap ) - 1;
q -> read = q -> write = 0;
atomic32_set ( & q -> refcount, 1 );
q -> sealed = false;
QMSG ( "%s: created queue with capacity %u, "
"bmask %#032b, imask %#032b.\n"
, __func__, q -> capacity, q -> bmask, q -> imask
);
* qp = q;
return 0;
}
KLockRelease ( q -> rl );
}
KSemaphoreRelease ( q -> wc );
}
KSemaphoreRelease ( q -> rc );
}
free ( q );
}
* qp = NULL;
}
return rc;
}
/*))) Two methods: _InitSidStorage() and _DisposeSidStorage()
/// You should call them before and after
(((*/
static
rc_t CC
_SidStorageInit ()
{
rc_t RCt;
struct KLock * tLock;
RCt = 0;
tLock = NULL;
if ( _IsSidStorageGood () ) {
return XFS_RC ( rcInvalid );
}
RCt = KLockMake ( & tLock );
if ( RCt == 0 ) {
BSTreeInit ( & _sSidStorage );
}
if ( RCt == 0 ) {
_sMutabor = tLock;
}
else {
if ( tLock != NULL ) {
KLockRelease ( tLock );
}
}
return RCt;
} /* _SidStorageInit () */
LIB_EXPORT
rc_t CC
XFSTreeDepotDispose ( const struct XFSTreeDepot * self )
{
rc_t RCt;
struct XFSTree * Tree;
KLock * mutabor;
RCt = 0;
Tree = NULL;
mutabor = NULL;
/*
pLogMsg ( klogDebug, " |<- TreeDepotDispose ( $(tree) )", "tree=%p", ( void * ) self );
*/
if ( self == 0 ) {
return 0;
}
/* That is not thread safe method :lol: */
Tree = ( struct XFSTree * ) self -> Tree;
mutabor = self -> mutabor;
free ( ( struct XFSTreeDepot * ) self );
XFSTreeRelease ( Tree );
KLockRelease ( mutabor );
return RCt;
} /* XFSTreeDepotDispose () */
/* Whack
*/
rc_t VCursorWhack ( VCursor *self )
{
#if VCURSOR_FLUSH_THREAD
if ( self -> flush_thread != NULL )
{
rc_t rc = KLockAcquire ( self -> flush_lock );
if ( rc == 0 )
{
while ( self -> flush_state == vfBusy )
{
MTCURSOR_DBG (( "VCursorWhack: waiting for thread to process\n" ));
KConditionWait ( self -> flush_cond, self -> flush_lock );
}
self -> flush_state = vfExit;
KConditionSignal ( self -> flush_cond );
KLockUnlock ( self -> flush_lock );
}
MTCURSOR_DBG (( "VCursorWhack: waiting on thread to exit\n" ));
KThreadWait ( self -> flush_thread, NULL );
}
MTCURSOR_DBG (( "VCursorWhack: finishing\n" ));
KThreadRelease ( self -> flush_thread );
KConditionRelease ( self -> flush_cond );
KLockRelease ( self -> flush_lock );
#endif
VCursorTerminatePagemapThread(self);
return VCursorDestroy ( self );
}
void destroy_temp_registry( temp_registry * self )
{
if ( self != NULL )
{
VectorWhack ( &self -> lists, destroy_list, NULL );
KLockRelease ( self -> lock );
free( ( void * ) self );
}
}
static void BAMReaderWhack(BAMReader *const self)
{
KThreadCancel(self->th);
KThreadWait(self->th, NULL);
BAMFileRelease(self->file);
KConditionRelease(self->need_data);
KConditionRelease(self->have_data);
KLockRelease(self->lock);
KThreadRelease(self->th);
}
/* Whack
*/
static
rc_t KQueueWhack ( KQueue *self )
{
rc_t rc;
QMSG ( "%s: releasing write semaphore\n", __func__ );
rc = KSemaphoreRelease ( self -> wc );
if ( rc == 0 )
{
QMSG ( "%s: releasing read semaphore\n", __func__ );
KSemaphoreRelease ( self -> rc );
QMSG ( "%s: releasing write lock\n", __func__ );
KLockRelease ( self -> wl );
QMSG ( "%s: releasing read lock\n", __func__ );
KLockRelease ( self -> rl );
free ( self );
QMSG ( "%s: done\n", __func__ );
}
return rc;
}
rc_t BAMReaderMake( const BAMReader **result,
char const headerText[],
char const path[] )
{
rc_t rc;
BAMReader *self = malloc(sizeof(BAMReader));
if ( self == NULL )
{
*result = NULL;
return RC(rcAlign, rcFile, rcConstructing, rcMemory, rcExhausted);
}
else
{
atomic32_set( & self->refcount, 1 );
rc = BAMFileMakeWithHeader( & self->file, headerText, "%s", path);
if ( rc != 0 )
{
free(self);
*result = 0;
}
else
*result = self;
}
self->nque = 0;
self->rc = 0;
self->eof = false;
rc = KLockMake(&self->lock);
if (rc == 0)
{
rc = KConditionMake(&self->have_data);
if (rc == 0)
{
rc = KConditionMake(&self->need_data);
if (rc == 0)
{
rc = KThreadMake(&self->th, BAMReaderThreadMain, self);
if (rc == 0)
return 0;
KConditionRelease(self->need_data);
}
KConditionRelease(self->have_data);
}
KLockRelease(self->lock);
}
return rc;
}
rc_t CC
XStatsDispose ( const struct XStats * self )
{
struct XStats * Stats = ( struct XStats * ) self;
if ( Stats != NULL ) {
if ( Stats -> mutabor != NULL ) {
KLockRelease ( Stats -> mutabor );
Stats -> mutabor = NULL;
}
_XStatsReset_NoLock ( self );
free ( Stats );
}
return 0;
} /* XStatDispose () */
static
rc_t CC
_SidStorageDispose ()
{
if ( ! _IsSidStorageGood () ) {
return 0;
}
/*) No check for return code
(*/
_ClearSidStorageNoLock ();
/*) Disengageing Lock
(*/
KLockRelease ( _sMutabor );
return 0;
} /* _SidStorageDispose () */
rc_t make_temp_registry( temp_registry ** registry, struct KFastDumpCleanupTask * cleanup_task )
{
KLock * lock;
rc_t rc = KLockMake ( &lock );
if ( rc == 0 )
{
temp_registry * p = calloc( 1, sizeof * p );
if ( p == 0 )
{
rc = RC( rcVDB, rcNoTarg, rcConstructing, rcMemory, rcExhausted );
ErrMsg( "make_temp_registry().calloc( %d ) -> %R", ( sizeof * p ), rc );
KLockRelease ( lock );
}
else
{
VectorInit ( &p -> lists, 0, 4 );
p -> lock = lock;
p -> cleanup_task = cleanup_task;
*registry = p;
}
}
return rc;
}
