/* 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; }