Re: [LMDB] Lockups with robust mutexes and crashing processes

[Marcos-David Dione <marcos-david.dione@amadeus.com>]

Howard Chu <hyc@symas.com> wrote on 23/11/2014
15:11:29:
> env_close does an munmap of the memory containing the mutex. According
> to the manpages, a robust mutex is supposed to automatically unlock
when 
> unmapped. Since this is not happening, it appears you've found a kernel
> bug. Regardless, the example is invalid. If you modify the code to
just 
> exit/abort/die without the bogus call to env_close, the other process
> wakes up correctly. E.g.
> 
> http://pastebin.com/9jieDnUz

        Ok, so now I managed
to mimic the situation with pure pthreads functions. 
The gist of it is as following:

1. we open a file.
2. we mmap the file and use the mem space to store
a mutex.
3. we lock the mutex.
4. we unmmap the file.
5. we close the file.

        Seen like that
I'm not sure if there's a defined behaviour for that. I'll 
ask in the glibc and/or kernel MLs and I'll come back
with the answer.

        Just for the record,
here's the full program:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>

void *tf (int n, int f, pthread_mutex_t *m) {
    int err = pthread_mutex_lock (m);
    printf ("ml: %d\n", err);
    if (err == EOWNERDEAD) {
        err = pthread_mutex_consistent_np
(m);
        printf ("mc: %d\n",
err);
        if (err) {
            puts ("pthread_mutex_consistent_np");
            exit (1);
        }
    } else if (err) {
        puts ("pthread_mutex_lock");
        exit (1);
    }
    printf ("%ld got the lock.\n",
n);
    sleep (3);
    /* exit without unlock */
    munmap (m, sizeof (pthread_mutex_t));
    close (f);
    printf ("%ld out\n", n);
    return NULL;
}

int main (void) {
    int err, f;
    pthread_mutex_t *m;
    pthread_mutexattr_t ma;

    pthread_mutexattr_init (&ma);
    err = pthread_mutexattr_setrobust_np
(&ma, PTHREAD_MUTEX_ROBUST_NP);
    if (err) {
        puts ("pthread_mutexattr_setrobust_np");
        return 1;
    }
    err = pthread_mutexattr_setpshared (&ma,
PTHREAD_PROCESS_SHARED);
    if (err) {
        puts ("pthread_mutexattr_setpshared");
        return 1;
    }
#ifdef ENABLE_PI
    if (pthread_mutexattr_setprotocol (&ma,
PTHREAD_PRIO_INHERIT) != 0) {
        puts ("pthread_mutexattr_setprotocol
failed");
        return 1;
    }
#endif

    f= open ("mutex.mmap", O_CREAT|O_TRUNC|O_RDWR);
    if (f<0) {
        puts ("open");
        return 1;
    }

    err= ftruncate (f, sizeof (pthread_mutex_t));
    if (err) {
        puts ("ftruncate");
        return 1;
    }

    m= (pthread_mutex_t *) mmap (NULL, sizeof
(pthread_mutex_t),
               
                 PROT_READ|PROT_WRITE,
MAP_SHARED, f, 0);

    err = pthread_mutex_init (m, &ma);
#ifdef ENABLE_PI
    if (err == ENOTSUP) {
        puts ("PI robust
mutexes not supported");
        return 0;
    }
#endif
    if (err) {
        puts ("pthread_mutex_init");
        return 1;
    }

    err= fork ();
    if (err==0) {
        tf (1, f, m);
    } else if (err>0) {
        int err2= fork ();
        if (err2==0) {
            tf (2, f,
m);
        } else if (err2>0)
{
            // sleep
(1);
            // kill
(err);
            // printf
("child killed\n");
            // sleep
(10);
            puts ("main
out");
        } else {
            puts ("fork2");
            return 1;
        }
    } else {
        puts ("fork1");
        return 1;
    }
    return 0;
}