Re: [Valgrind-developers] Hang in err_disable4

[Paul F. <pj...@wa...>]

Hi
 
Sorry for the formatting, I'm writing this on my FreeBSD machine and using a web mail client. This time in plain text.

The stacktrace 

* frame #0: 0x0000000038088b92 memcheck-amd64-freebsd`do_syscall_WRK at m_syscall.c:383:1
frame #1: 0x0000000038088c2e memcheck-amd64-freebsd`vgPlain_do_syscall(sysno=3, a1=469737, a2=17224604422, a3=1, a4=0, a5=0, a6=0, a7=0, a8=0) at m_syscall.c:1097:10
frame #2: 0x0000000038070776 memcheck-amd64-freebsd`vgPlain_read(fd=469737, buf=0x0000000402aa9b06, count=1) at m_libcfile.c:247:17
frame #3: 0x0000000038173292 memcheck-amd64-freebsd`vgModuleLocal_sema_down(sema=0x0000000402006640, as_LL='\0') at sema.c:107:10
frame #4: 0x0000000038172f2a memcheck-amd64-freebsd`acquire_sched_lock(p=0x0000000402006640) at sched-lock-generic.c:69:4
frame #5: 0x0000000038172e7b memcheck-amd64-freebsd`vgModuleLocal_acquire_sched_lock(p=0x0000000402006640) at sched-lock.c:88:26
frame #6: 0x00000000380e6a7c memcheck-amd64-freebsd`vgPlain_acquire_BigLock_LL(who=0x0000000000000000) at scheduler.c:425:4
frame #7: 0x00000000380e6659 memcheck-amd64-freebsd`vgPlain_acquire_BigLock(tid=1, who="VG_(vg_yield)") at scheduler.c:349:4
frame #8: 0x00000000380e6e4f memcheck-amd64-freebsd`vgPlain_vg_yield at scheduler.c:530:4
frame #9: 0x00000000380ee88c memcheck-amd64-freebsd`vgPlain_post_syscall(tid=1) at syswrap-main.c:2470:7
frame #10: 0x00000000380ee326 memcheck-amd64-freebsd`vgPlain_client_syscall(tid=1, trc=73) at syswrap-main.c:2351:4
frame #11: 0x00000000380e86e2 memcheck-amd64-freebsd`handle_syscall(tid=1, trc=73) at scheduler.c:1211:4
frame #12: 0x00000000380e90b3 memcheck-amd64-freebsd`vgPlain_scheduler(tid=1) at scheduler.c:1529:3
frame #13: 0x0000000038100540 memcheck-amd64-freebsd`thread_wrapper(tidW=1) at syswrap-freebsd.c:95:10
frame #14: 0x00000000381006bc memcheck-amd64-freebsd`run_a_thread_NORETURN(tidW=1) at syswrap-freebsd.c:133:10

Source code (it's err_disable4.c with a few mods)

#include 
#include 
#include 
#include 

#include 
#include 
/* PTHREAD_STACK_MIN */
#include "../include/valgrind.h"

char* block = NULL;
# if !defined(VGO_darwin)
sem_t sem;
# else
sem_t *sem;
static const char *semname = "Semaphore1";
# endif

__attribute__((noinline)) void usechar ( char c )
{
// Spook gcc into believing mysterious bad things are
// happening behind its back, and that 'c' is definitely
// used in some (unknown) way.
__asm__ __volatile__("" : : "r"(c) : "memory","cc");
}

__attribute__((noinline)) void err ( void )
{
usechar( block[5] );
}

void* child_fn_1 ( void* arg )
{
// Disable error reporting, then wait to exit
VALGRIND_DISABLE_ERROR_REPORTING;

fprintf(stderr, "fn1 calling sem_wait\n");

# if !defined(VGO_darwin)
int r = sem_wait(&sem); assert(!r);
# else
int r = sem_wait(sem); assert(!r);
# endif
return NULL;
}

void* child_fn_2 ( void* arg )
{
// make an error, then wait to exit

fprintf(stderr, "fn2 calling err\n");

err();

fprintf(stderr, "fn2 calling sem_wait\n");

# if !defined(VGO_darwin)
int r = sem_wait(&sem); assert(!r);
# else
int r = sem_wait(sem); assert(!r);
# endif
return NULL;
}

#define NTHREADS 1 // VG_N_THREADS - 2

int main ( void )
{
int r, i;
pthread_t child[NTHREADS];

block = malloc(10);
free(block);

// part 1
fprintf(stderr, "\n-------- Letting %d threads exit "
"w/ errs disabled ------\n\n",
NTHREADS);

// set up the semaphore
# if !defined(VGO_darwin)
r = sem_init(&sem, 0, 0); assert(!r);
# else
sem = sem_open(semname, O_CREAT, 0777, 0); assert(!(sem == SEM_FAILED));
# endif

fprintf(stderr, "opened sem\n");

#if !defined(VGO_freebsd)
pthread_attr_t attr;
r = pthread_attr_init(&attr); assert(!r);
r = pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
#endif


// create N threads to do child_fn_1 ...
for (i = 0; i < NTHREADS; i++) {
r = pthread_create(&child[i], NULL, child_fn_1, NULL);
assert(!r);
}

fprintf(stderr, "created fn1\n");


// let them all exit
for (i = 0; i < NTHREADS; i++) {
# if !defined(VGO_darwin)
r = sem_post(&sem); assert(!r);
# else
r = sem_post(sem); assert(!r);
# endif
}

fprintf(stderr, "posted dem\n");

// join
for (i = 0; i < NTHREADS; i++) {
r = pthread_join(child[i], NULL); assert(!r);
}

fprintf(stderr, "joined\n");

// part 2

fprintf(stderr, "\n-------- Letting %d threads make an error "
"------\n\n",
NTHREADS);
// semaphore is already back at zero

// create N threads to do child_fn_2 ...
for (i = 0; i < NTHREADS; i++) {
r = pthread_create(&child[i], NULL, child_fn_2, NULL);
assert(!r);
}

fprintf(stderr, "created fn2\n");

// let them all exit
for (i = 0; i < NTHREADS; i++) {
# if !defined(VGO_darwin)
r = sem_post(&sem); assert(!r);
# else
r = sem_post(sem); assert(!r);
# endif
}

fprintf(stderr, "posted sem again\n");

// join
for (i = 0; i < NTHREADS; i++) {
r = pthread_join(child[i], NULL); assert(!r);
}

fprintf(stderr, "waited again\n");

// Print the final error counts. There need to be 498 errors
// in 1 context. Anything else, and something is not right.
int nerrors = VALGRIND_COUNT_ERRORS;
fprintf(stderr, "\n-------- Got %d errors (expected %d ==> %s) ------\n\n", 
nerrors, NTHREADS, nerrors == NTHREADS ? "PASS" : "FAIL" );

return 0;
}