Complete Flags Reference Table

Section A: Flags for POSIX Thread Creation

Example 1 — Simulate a Thread (CLONE_VM + CLONE_FILES + CLONE_SIGHAND)

/* thread_like_clone.c — Create a thread-like child sharing memory */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sched.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>

#define STACK_SIZE (64 * 1024)

int shared_counter = 0;   /* In shared memory — both parent and child see changes */

static int child_func(void *arg)
{
    printf("[Child]  shared_counter before = %d\n", shared_counter);
    shared_counter += 100;    /* This modifies PARENT's memory too (CLONE_VM) */
    printf("[Child]  shared_counter after  = %d\n", shared_counter);
    return 0;
}

int main(void)
{
    char *stack     = malloc(STACK_SIZE);
    char *stack_top = stack + STACK_SIZE;

    shared_counter = 5;
    printf("[Parent] shared_counter = %d (before clone)\n", shared_counter);

    pid_t pid = clone(
        child_func,
        stack_top,
        CLONE_VM | CLONE_FILES | CLONE_SIGHAND | SIGCHLD,
        NULL
    );
    if (pid == -1) { perror("clone"); exit(1); }

    waitpid(pid, NULL, 0);

    /* Because CLONE_VM was set, the child's write is visible here */
    printf("[Parent] shared_counter = %d (after child modified it)\n",
           shared_counter);

    free(stack);
    return 0;
}
/*
 * Output:
 * [Parent] shared_counter = 5 (before clone)
 * [Child]  shared_counter before = 5
 * [Child]  shared_counter after  = 105
 * [Parent] shared_counter = 105 (after child modified it)
 *
 * Without CLONE_VM, parent would still see 5.
 */

Section B: Thread Groups — CLONE_THREAD, TID, TGID

Thread Group — TID vs TGID Diagram

Example 2 — CLONE_THREAD: Shared PID (TGID)

/* clone_thread.c — Show TID vs TGID with CLONE_THREAD */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sched.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/syscall.h>
#include <unistd.h>

#define STACK_SIZE (64 * 1024)

/* gettid() is not in libc — call it directly */
static pid_t gettid_wrapper(void)
{
    return (pid_t) syscall(SYS_gettid);
}

static int thread_func(void *arg)
{
    printf("[Thread] PID (TGID) via getpid()  = %d\n", getpid());
    printf("[Thread] TID        via gettid()  = %d\n", gettid_wrapper());
    sleep(1);  /* Give parent time to print its info */
    return 0;
}

int main(void)
{
    char *stack     = malloc(STACK_SIZE);
    char *stack_top = stack + STACK_SIZE;

    printf("[Main]   PID (TGID) via getpid()  = %d\n", getpid());
    printf("[Main]   TID        via gettid()  = %d\n", gettid_wrapper());

    pid_t tid = clone(
        thread_func,
        stack_top,
        /* CLONE_THREAD requires CLONE_SIGHAND which requires CLONE_VM */
        CLONE_VM | CLONE_SIGHAND | CLONE_THREAD,
        NULL
    );
    if (tid == -1) { perror("clone"); exit(1); }

    printf("[Main]   clone() returned TID      = %d\n", tid);

    /*
     * Cannot use waitpid() for CLONE_THREAD children directly.
     * The thread must be joined via futex or we just sleep here.
     */
    sleep(2);

    free(stack);
    return 0;
}
/*
 * Output (example):
 * [Main]   PID (TGID) via getpid()  = 12345
 * [Main]   TID        via gettid()  = 12345
 * [Main]   clone() returned TID      = 12346
 * [Thread] PID (TGID) via getpid()  = 12345   ← SAME as parent!
 * [Thread] TID        via gettid()  = 12346   ← Different
 */

Section C: Namespace Flags — Building Containers

Container Isolation Model

Example 3 — New UTS Namespace (Change Hostname in Child)

/* clone_newuts.c — Child gets its own hostname via CLONE_NEWUTS */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sched.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>

#define STACK_SIZE (64 * 1024)

static int child_func(void *arg)
{
    char *new_hostname = (char *) arg;

    /* Set a new hostname — only affects this UTS namespace */
    if (sethostname(new_hostname, strlen(new_hostname)) == -1) {
        perror("sethostname"); return 1;
    }

    char buf[256];
    gethostname(buf, sizeof(buf));
    printf("[Child]  hostname = '%s'\n", buf);
    return 0;
}

int main(void)
{
    char *stack     = malloc(STACK_SIZE);
    char *stack_top = stack + STACK_SIZE;
    char  host_before[256];

    gethostname(host_before, sizeof(host_before));
    printf("[Parent] hostname before = '%s'\n", host_before);

    /* CLONE_NEWUTS: child gets its own UTS namespace */
    /* Requires CAP_SYS_ADMIN (root) */
    pid_t pid = clone(child_func, stack_top,
                      CLONE_NEWUTS | SIGCHLD,
                      "my-container-host");
    if (pid == -1) { perror("clone"); exit(1); }

    waitpid(pid, NULL, 0);

    /* Parent's hostname is UNCHANGED */
    char host_after[256];
    gethostname(host_after, sizeof(host_after));
    printf("[Parent] hostname after  = '%s' (unchanged)\n", host_after);

    free(stack);
    return 0;
}
/* Run as root: sudo ./clone_newuts
 * Output:
 * [Parent] hostname before = 'myserver'
 * [Child]  hostname = 'my-container-host'
 * [Parent] hostname after  = 'myserver'    ← Parent unaffected
 */

Section D: Threading Support Flags — SETTID / CLEARTID

/* Without CLONE_PARENT_SETTID — RACE CONDITION */
tid = clone(...);
/* If child exits BEFORE this assignment completes,
   the signal handler fires with tid still = 0.
   Handler cannot identify the thread. BROKEN! */

/* With CLONE_PARENT_SETTID — SAFE */
/* Kernel writes TID to &new_tid BEFORE clone() returns,
   so no matter when the signal fires, new_tid has the right value. */
clone(..., CLONE_PARENT_SETTID, ..., &new_tid, ...);

Section E: Mount Namespaces — CLONE_NEWNS

CLONE_NEWNS gives the child its own copy of the parent’s mount namespace. Calls to mount() and umount() in the child do not affect the parent’s view of the filesystem. This is the basis for container isolation.

Interview Questions