static void
del_stk(rust_task *task, stk_seg *stk)
{
VALGRIND_STACK_DEREGISTER(stk->valgrind_id);
LOGPTR(task->sched, "freeing stk segment", (uintptr_t)stk);
task->free(stk);
}
int main(int argc, char **argv)
{
int c1 = init_context(&ctx1);
int c2 = init_context(&ctx2);
makecontext(&ctx1, (void (*)()) hello, 1, &ctx2);
makecontext(&ctx2, (void (*)()) hello, 1, &ctx1);
swapcontext(&oldc, &ctx1);
VALGRIND_STACK_DEREGISTER(c1);
VALGRIND_STACK_DEREGISTER(c2);
return 0;
}
void FiberStack::free() {
if(!address_) return;
#ifdef HAVE_VALGRIND_H
VALGRIND_STACK_DEREGISTER(valgrind_id_);
#endif
::free(address_);
address_ = 0;
}
void fiber_free(ACL_FIBER *fiber)
{
#ifdef USE_VALGRIND
VALGRIND_STACK_DEREGISTER(fiber->vid);
#endif
if (fiber->context)
acl_myfree(fiber->context);
acl_myfree(fiber->buff);
acl_myfree(fiber);
}
void stack_allocator_memory::deallocate(stack_context & ctx)
{
assert(ctx.sp);
assert(stack_traits::minimum_size() <= ctx.size);
assert(stack_traits::is_unbounded() || (stack_traits::maximum_size() >= ctx.size));
#if defined(COPP_MACRO_USE_VALGRIND)
VALGRIND_STACK_DEREGISTER( ctx.valgrind_stack_id);
#endif
}
static void* child_fn_0 ( void* arg )
{
grow_the_stack();
bad_things_below_sp();
if (setjmp(goback)) {
describe_many();
} else
bad_things_till_guard_page();
if (shake_with_wrong_registration) {
// Do whatever stupid things we could imagine
// with stack registration and see no explosion happens
// Note: this is executed only if an arg is given to the program.
//
const int pgsz = guess_pagesize();
int stackid;
fprintf(stderr, "\n\nShaking after unregistering stack\n");
// Assuming our first stack was automatically registered as nr 1
VALGRIND_STACK_DEREGISTER(1);
// Test with no stack registered
describe_many();
fprintf(stderr, "\n\nShaking with small stack\n");
stackid = VALGRIND_STACK_REGISTER((void*) VG_ROUNDDN(&stackid, pgsz),
(void*) VG_ROUNDUP(&stackid, pgsz));
describe_many();
VALGRIND_STACK_DEREGISTER(stackid);
fprintf(stderr, "\n\nShaking with huge stack\n");
stackid = VALGRIND_STACK_REGISTER((void*) 0x0,
(void*) VG_ROUNDUP(&stackid, 2<<20));
describe_many();
VALGRIND_STACK_DEREGISTER(stackid);
}
return NULL;
}
void stack_allocator_malloc::deallocate(stack_context & ctx)
{
assert(ctx.sp);
assert(stack_traits::minimum_size() <= ctx.size);
assert(stack_traits::is_unbounded() || (stack_traits::maximum_size() >= ctx.size));
#if defined(COPP_MACRO_USE_VALGRIND)
VALGRIND_STACK_DEREGISTER( ctx.valgrind_stack_id);
#endif
void* start_ptr = static_cast< char * >(ctx.sp) - ctx.size;
free(start_ptr);
}
void deallocate( stack_context & sctx) {
BOOST_ASSERT( sctx.sp);
BOOST_ASSERT( traits_type::minimum_size() <= sctx.size);
BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= sctx.size) );
#if defined(BOOST_USE_VALGRIND)
VALGRIND_STACK_DEREGISTER( sctx.valgrind_stack_id);
#endif
void * vp = static_cast< char * >( sctx.sp) - sctx.size;
std::free( vp);
}
void deallocate( stack_context & sctx) {
BOOST_ASSERT( sctx.sp);
BOOST_ASSERT( traits_type::minimum_size() <= sctx.size);
BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= sctx.size) );
#if defined(BOOST_USE_VALGRIND)
VALGRIND_STACK_DEREGISTER( sctx.valgrind_stack_id);
#endif
void * vp = static_cast< char * >( sctx.sp) - sctx.size;
// conform to POSIX.4 (POSIX.1b-1993, _POSIX_C_SOURCE=199309L)
::munmap( vp, sctx.size);
}
static void smx_ctx_sysv_free(smx_context_t context)
{
if (context) {
#ifdef HAVE_VALGRIND_VALGRIND_H
VALGRIND_STACK_DEREGISTER(((smx_ctx_sysv_t)
context)->valgrind_stack_id);
#endif /* HAVE_VALGRIND_VALGRIND_H */
}
smx_ctx_base_free(context);
}
/* Gets called when coroutine handle is closed. */
static void dill_cr_close(struct dill_hvfs *vfs) {
struct dill_ctx_cr *ctx = &dill_getctx->cr;
struct dill_cr *cr = dill_cont(vfs, struct dill_cr, vfs);
/* If the coroutine has already finished, we are done. */
if(!cr->done) {
/* No blocking calls from this point on. */
cr->no_blocking1 = 1;
/* Resume the coroutine if it was blocked. */
if(!cr->ready.next)
dill_cancel(cr, ECANCELED);
/* Wait for the coroutine to stop executing. With no clauses added,
the only mechanism to resume is through dill_cancel(). This is not
really a blocking call, although it looks like one. Given that the
coroutine that is being shut down is not permitted to block, we
should get control back pretty quickly. */
cr->closer = ctx->r;
int rc = dill_wait();
/* This assertion triggers when coroutine tries to close a bundle that
it is part of. There's no sane way to handle that so let's just
crash the process. */
dill_assert(!(rc == -1 && errno == ECANCELED));
dill_assert(rc == -1 && errno == 0);
}
#if defined DILL_CENSUS
/* Find the first overwritten byte on the stack.
Determine stack usage based on that. */
uint8_t *bottom = ((uint8_t*)cr) - cr->stacksz;
int i;
for(i = 0; i != cr->stacksz; ++i) {
if(bottom[i] != 0xa0 + (i % 13)) {
/* dill_cr is located on the stack so we have to take that into
account. Also, it may be necessary to align the top of the stack
to a 16-byte boundary, so add 16 bytes to account for that. */
size_t used = cr->stacksz - i - sizeof(struct dill_cr) + 16;
if(used > cr->census->max_stack)
cr->census->max_stack = used;
break;
}
}
#endif
#if defined DILL_VALGRIND
VALGRIND_STACK_DEREGISTER(cr->sid);
#endif
/* Now that the coroutine is finished, deallocate it. */
if(!cr->mem) dill_freestack(cr + 1);
}
void
coro_stack_free (struct coro_stack *stack)
{
#if CORO_FIBER
/* nop */
#else
#if CORO_USE_VALGRIND
VALGRIND_STACK_DEREGISTER (stack->valgrind_id);
#endif
#if CORO_MMAP
if (stack->sptr)
munmap ((void*)((char *)stack->sptr - CORO_GUARDPAGES * PAGESIZE),
stack->ssze + CORO_GUARDPAGES * PAGESIZE);
#else
free (stack->sptr);
#endif
#endif
}
void st_thread_exit(void *retval)
{
_st_thread_t *thread = _ST_CURRENT_THREAD();
thread->retval = retval;
_st_thread_cleanup(thread);
_st_active_count--;
if (thread->term) {
/* Put thread on the zombie queue */
thread->state = _ST_ST_ZOMBIE;
_ST_ADD_ZOMBIEQ(thread);
/* Notify on our termination condition variable */
st_cond_signal(thread->term);
/* Switch context and come back later */
_ST_SWITCH_CONTEXT(thread);
/* Continue the cleanup */
st_cond_destroy(thread->term);
thread->term = NULL;
}
#ifdef DEBUG
_ST_DEL_THREADQ(thread);
#endif
#ifndef NVALGRIND
if (!(thread->flags & _ST_FL_PRIMORDIAL)) {
VALGRIND_STACK_DEREGISTER(thread->stack->valgrind_stack_id);
}
#endif
if (!(thread->flags & _ST_FL_PRIMORDIAL)) {
_st_stack_free(thread->stack);
}
/* Find another thread to run */
_ST_SWITCH_CONTEXT(thread);
free(thread);
(*_st_eventsys->free)();
}
void destroy_coro(Worker * c) {
total_coros--;
#ifdef ENABLE_VALGRIND
if( c->valgrind_stack_id != -1 ) {
VALGRIND_STACK_DEREGISTER( c->valgrind_stack_id );
}
#endif
if( c->base != NULL ) {
// disarm guard page
checked_mprotect( c->base, 4096, PROT_READ | PROT_WRITE );
checked_mprotect( (char*)c->base + c->ssize + 4096, 4096, PROT_READ | PROT_WRITE );
#ifdef CORO_PROTECT_UNUSED_STACK
// enable writes to stack so we can deallocate
checked_mprotect( (void*)((intptr_t)c->base + 4096), c->ssize, PROT_READ | PROT_WRITE );
checked_mprotect( (void*)(c), 4096, PROT_READ | PROT_WRITE );
#endif
remove_coro(c); // remove from debugging list of coros
Grappa::impl::locale_shared_memory.deallocate(c->base);
}
}
//fonction appelée à la terminaison du programme pour libérer la mémoire
void threads_destroy()
{
thread_t item, tmp_item;
free(return_t.uc_stack.ss_sp);
for (item = TAILQ_FIRST(&(threadList.list)); item != NULL; item = tmp_item)
{
tmp_item = TAILQ_NEXT(item, entries);
/* Retire l'élément de la liste*/
TAILQ_REMOVE(&(threadList.list), item, entries);
/* Libère l'espace alloué */
VALGRIND_STACK_DEREGISTER(item->valgrind_stackid);
//free(item->context.uc_stack.ss_sp);
free(item);
}
for (item = TAILQ_FIRST(&(threadList.list_sleeping)); item != NULL; item = tmp_item)
{
tmp_item = TAILQ_NEXT(item, entries);
/* Retire l'élément de la liste*/
TAILQ_REMOVE(&(threadList.list_sleeping), item, entries);
/* Libère l'espace alloué */
free(item->context.uc_stack.ss_sp);
free(item);
}
for (item = TAILQ_FIRST(&(threadList.list_dead)); item != NULL; item = tmp_item)
{
tmp_item = TAILQ_NEXT(item, entries);
/* Retire l'élément de la liste*/
TAILQ_REMOVE(&(threadList.list_dead), item, entries);
/* Libère l'espace alloué */
free(item->context.uc_stack.ss_sp);
free(item);
}
}
static void startup(void *stack_top, unsigned long long stack_id, void (*func)(void *args), void *args)
{
clear(&trash);
func(args);
trash = stack_top;
#ifdef __VALGRIND_H
VALGRIND_STACK_DEREGISTER(stack_id);
#endif
if((--task_count == 0) && ucp_main)
setcontext(ucp_main);
if(ucp_next)
{
ucontext_t *ucp = ucp_next;
ucp_next = ucp->uc_link;
setcontext(ucp);
}
struct epoll_event event;
while(epoll_wait(epfd, &event, 1, -1) != 1);
setcontext(event.data.ptr);
}
static inline void valgrind_stack_deregister(CoroutineUContext *co)
{
VALGRIND_STACK_DEREGISTER(co->valgrind_stack_id);
}
int thread_join(thread_t thread, void **retval) {
int found = 0;
unsigned int i;
for(i = 0; i < g_list_length(ready_list); i++) {
thread_t t = g_list_nth_data(ready_list, i);
if(thread == t)
found = 1;
else {
if(g_list_find(t->sleeping_list, thread) != NULL)
found = 1;
}
}
if (found){
thread_t next, current = g_list_nth_data(ready_list, 0);
ready_list = g_list_remove(ready_list, current);
thread->sleeping_list = g_list_append(thread->sleeping_list, current);
next = g_list_nth_data(ready_list, 0);
if(swapcontext(¤t->uc, &next->uc) == -1)
return -1;
*retval = current->retval;
thread_sigTreat(current);
if (g_list_index(zombie_list, thread) != -1){
zombie_list = g_list_remove(zombie_list,thread);
free(thread->uc.uc_stack.ss_sp);
/* juste avant de libérer la pile */
VALGRIND_STACK_DEREGISTER(thread->stackid);
free(thread);
}
thread_t cur_t = g_list_nth_data(ready_list, 0);
if(g_list_length(ready_list)==1 && g_list_length(cur_t->sleeping_list)==0){
/* fprintf(stderr, "Total Annihilation\n"); */
g_list_free(cur_t->sleeping_list);
free(cur_t);
g_list_free(ready_list);
ready_list=NULL;
}
}
else if (g_list_index(zombie_list,thread)!=-1){
thread_t waiter = g_list_nth_data(zombie_list,(g_list_index(zombie_list,
thread)));
*retval = waiter->retval;
zombie_list = g_list_remove(zombie_list,thread);
free(thread->uc.uc_stack.ss_sp);
/* juste avant de libérer la pile */
VALGRIND_STACK_DEREGISTER(thread->stackid);
/* free(thread->retval); */
free(thread);
}
else {
*retval = NULL;
fprintf(stderr, "le thread %p n'existe pas\n", thread);
return -1;
}
return 0;
}
void fiberYield()
{
/* If we are in a fiber, switch to the main context */
if ( inFiber )
{
/* Store the current state */
if ( setjmp( fiberList[ currentFiber ].context ) )
{
/* Returning via longjmp (resume) */
LF_DEBUG_OUT1( "Fiber %d resuming...", currentFiber );
}
else
{
LF_DEBUG_OUT1( "Fiber %d yielding the processor...", currentFiber );
/* Saved the state: Let's switch back to the main state */
longjmp( mainContext, 1 );
}
}
/* If we are in main, dispatch the next fiber */
else
{
if ( numFibers == 0 ) return;
/* Save the current state */
if ( setjmp( mainContext ) )
{
/* The fiber yielded the context to us */
inFiber = 0;
if ( ! fiberList[currentFiber].active )
{
/* If we get here, the fiber returned and is done! */
LF_DEBUG_OUT1( "Fiber %d returned, cleaning up.", currentFiber );
free( fiberList[currentFiber].stack );
#ifdef VALGRIND
VALGRIND_STACK_DEREGISTER(fiberList[currentFiber].stackId);
#endif
/* Swap the last fiber with the current, now empty, entry */
-- numFibers;
if ( currentFiber != numFibers )
{
fiberList[ currentFiber ] = fiberList[ numFibers ];
}
/* Clean up the entry */
fiberList[numFibers].stack = 0;
fiberList[numFibers].function = 0;
fiberList[numFibers].active = 0;
}
else
{
LF_DEBUG_OUT1( "Fiber %d yielded execution.", currentFiber );
}
}
else
{
/* Saved the state so call the next fiber */
currentFiber = (currentFiber + 1) % numFibers;
LF_DEBUG_OUT1( "Switching to fiber %d", currentFiber );
inFiber = 1;
longjmp( fiberList[ currentFiber ].context, 1 );
}
}
return;
}
static void valgrind_unregister(const int64_t id){
#ifdef VALGRIND_CHECK_ENABLE
VALGRIND_STACK_DEREGISTER(id);
#endif
}
void
deregister_valgrind_stack(stk_seg *stk) {
VALGRIND_STACK_DEREGISTER(stk->valgrind_id);
}
void
rust_valgrind_stack_deregister(unsigned int id) {
VALGRIND_STACK_DEREGISTER(id);
}
/// Deregister a stack with valgrind so that it can be reused.
static void _deregister(ustack_t *thread) {
VALGRIND_STACK_DEREGISTER(thread->stack_id);
}