The child process does not start with syscall(SYS_clone3, ...) + CLONE_VM

Linux Developer Forum Linux Questions/Help
1

Hello, everyone.

It is necessary that the calling process and the child process are in the same memory space.
Therefore, I use the CLONE_VM flag.
But the child process does not start.
It looks like something is wrong with the allocation of memory for the stack.
Could you please explain the reason?

#define _DEFAULT_SOURCE         /* syscall() */
#define _GNU_SOURCE
#define _FILE_OFFSET_BITS 64    /* getrlimit() */

#include <sched.h>              /* CLONE_* constants */
#include <linux/sched.h>        /* struct clone_args */
#include <sys/syscall.h>        /* SYS_* constants */
#include <unistd.h>

#include <stdint.h>             /* uintptr_t */

#include <stdio.h>
#include <stdlib.h>
#include <err.h>                /* err() */
#include <string.h>
#include <unistd.h>

#include <sys/resource.h>
#include <sys/mman.h>
#include <signal.h>

void spawn(void)
{
    struct rlimit       rlim;
    struct clone_args   cl_args;
    __u64               stack_size;
    __u64               *stackBot;
    __u64               *stackTop;
    pid_t               pid;

    memset(&cl_args, 0, sizeof(cl_args));

    if (getrlimit(RLIMIT_STACK, &rlim) == -1) {
        err(EXIT_FAILURE, "getrlimit");
    }
    stack_size = rlim.rlim_cur;

    stackBot = (__u64 *)
        mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
             MAP_PRIVATE | MAP_ANONYMOUS | MAP_GROWSDOWN |
             MAP_STACK, -1, 0);
    if (stackBot == MAP_FAILED) {
        err(EXIT_FAILURE, "mmap");
    }

    stackTop = stackBot + (stack_size / sizeof(__u64));

    cl_args.flags       = CLONE_FILES | CLONE_IO | CLONE_VM;
    cl_args.exit_signal = SIGCHLD;
    cl_args.stack       = (__u64) (uintptr_t) stackTop;
    cl_args.stack_size  = stack_size;

    pid = syscall(SYS_clone3, &cl_args, sizeof(cl_args));
    switch(pid) {
        case -1:
            munmap(stackBot, stack_size);
            err(EXIT_FAILURE, "syscall");
        case 0:     /* Child */
            printf("Hello from child!\n");
            munmap(stackBot, stack_size);
            break;
        default:    /* Parent */
            printf("Hello from parent!\n");
            break;
    }
}

int
main(int argc, char *argv[])
{
    spawn();

    printf("Before last while\n");
    while(1) {
    }

    return EXIT_SUCCESS;
}