[musl] BUG: Calling readdir/dirfd after vfork will cause deadlock.

[Nick Peng <pymumu@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 2603 bytes --]

Description:  After vfork, calling functions such as readdir/dirfd may
cause deadlock. GNU C is OK.
                     Also tested on x86-64 with musl, no deadlock, but
seems never exit, slower than GNU C.
Version: latest, musl-1.2.3
OS: debian bullseye 64bit OS. and asus router
CPU: raspberrypi aarch64， mips32
Reproduce Code:

#include <dirent.h>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <string.h>

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

struct tlog_log *logs = NULL;
int do_exit = 0;

void *test(void *arg)
{
    int i = 0;

    for (i = 0; i < 10000000; i++) {
        char *b = malloc(4096);
        memset(b, 0, 4096);
        free(b);
    }
    do_exit = 1;
    return NULL;
}

void lockfunc()
{
    char path_name[4096];
    DIR *dir = NULL;
    struct dirent *ent;

    snprintf(path_name, sizeof(path_name), "/proc/self/fd/");
    dir = opendir(path_name);
    if (dir == NULL) {
        goto errout;
    }

    while ((ent = readdir(dir)) != NULL) {
    }

    closedir(dir);

    return;
errout:
    if (dir) {
        closedir(dir);
    }

    return;
}

void *test_fork(void *arg)
{
    int count = 0;
    while (do_exit == 0) {
        printf("test fork count %d\n", count++);
        int pid = vfork();
        if (pid < 0) {
            return NULL;
        } else if (pid == 0) {
            lockfunc();
            _exit(0);
        }

        int status;
        waitpid(pid, &status, 0);
    }

    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_attr_t attr;
    pthread_t threads[10];
    pthread_t fork_test;
    int i;
    int ret;

    pthread_attr_init(&attr);

    ret = pthread_create(&fork_test, &attr, test_fork, NULL);

    for (i = 0; i < 10; i++) {
        ret = pthread_create(&threads[i], &attr, test, NULL);
        if (ret != 0) {
            return 1;
        }
    }

    for (i = 0; i < 10; i++) {
        void *retval = NULL;
        pthread_join(threads[i], &retval);
    }

    void *retval = NULL;
    pthread_join(fork_test, &retval);
    printf("exit\n");
    getchar();
    return 0;
}


Log：
pi@raspberrypi:~/code/tinylog/test $ ./test
test fork count 0
test fork count 1   <-- lock here
^C

gdb backtrace:
x0000000000409524 in __lock ()
(gdb) bt
#0  0x0000000000409524 in __lock ()
#1  0x0000000000406278 in __libc_malloc_impl ()

[-- Attachment #2: Type: text/html, Size: 3318 bytes --]